Bug 1340655 - remove h1 pipeline support r=mayhemer
authorPatrick McManus <mcmanus@ducksong.com>
Fri, 17 Feb 2017 15:35:37 -0500
changeset 374657 fb3c9156f1b99c4b08e7c35b98ac27756c357687
parent 374656 08df0e07f0ba02a27e532b25a0d3415166a6bba1
child 374658 5e87b990f4b08e32c23e1377a4393d34ec121553
push id10863
push userjlorenzo@mozilla.com
push dateMon, 06 Mar 2017 23:02:23 +0000
treeherdermozilla-aurora@0931190cd725 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmayhemer
bugs1340655
milestone54.0a1
Bug 1340655 - remove h1 pipeline support r=mayhemer
modules/libpref/init/all.js
netwerk/ipc/NeckoChannelParams.ipdlh
netwerk/protocol/http/ConnectionDiagnostics.cpp
netwerk/protocol/http/Http2Push.cpp
netwerk/protocol/http/Http2Session.cpp
netwerk/protocol/http/HttpBaseChannel.cpp
netwerk/protocol/http/HttpBaseChannel.h
netwerk/protocol/http/HttpChannelChild.cpp
netwerk/protocol/http/HttpChannelParent.cpp
netwerk/protocol/http/HttpChannelParent.h
netwerk/protocol/http/NullHttpTransaction.cpp
netwerk/protocol/http/TunnelUtils.cpp
netwerk/protocol/http/TunnelUtils.h
netwerk/protocol/http/moz.build
netwerk/protocol/http/nsAHttpConnection.h
netwerk/protocol/http/nsAHttpTransaction.h
netwerk/protocol/http/nsHttp.h
netwerk/protocol/http/nsHttpChannel.cpp
netwerk/protocol/http/nsHttpConnection.cpp
netwerk/protocol/http/nsHttpConnection.h
netwerk/protocol/http/nsHttpConnectionMgr.cpp
netwerk/protocol/http/nsHttpConnectionMgr.h
netwerk/protocol/http/nsHttpHandler.cpp
netwerk/protocol/http/nsHttpHandler.h
netwerk/protocol/http/nsHttpPipeline.cpp
netwerk/protocol/http/nsHttpPipeline.h
netwerk/protocol/http/nsHttpTransaction.cpp
netwerk/protocol/http/nsHttpTransaction.h
netwerk/protocol/http/nsIHttpChannel.idl
netwerk/test/unit/test_assoc.js
netwerk/test/unit/xpcshell.ini
toolkit/components/telemetry/Histograms.json
toolkit/components/telemetry/histogram-whitelists.json
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -1514,37 +1514,16 @@ pref("network.http.enablePerElementRefer
 pref("network.http.redirection-limit", 20);
 
 // Enable http compression: comment this out in case of problems with 1.1
 // NOTE: support for "compress" has been disabled per bug 196406.
 // NOTE: separate values with comma+space (", "): see bug 576033
 pref("network.http.accept-encoding", "gzip, deflate");
 pref("network.http.accept-encoding.secure", "gzip, deflate, br");
 
-pref("network.http.pipelining"      , false);
-pref("network.http.pipelining.ssl"  , false); // disable pipelining over SSL
-pref("network.http.pipelining.abtest", false);
-pref("network.http.proxy.pipelining", false);
-
-// Max number of requests in the pipeline
-pref("network.http.pipelining.maxrequests" , 32);
-
-// An optimistic request is one pipelined when policy might allow a new
-// connection instead
-pref("network.http.pipelining.max-optimistic-requests" , 4);
-
-pref("network.http.pipelining.aggressive", false);
-pref("network.http.pipelining.maxsize" , 300000);
-pref("network.http.pipelining.reschedule-on-timeout", true);
-pref("network.http.pipelining.reschedule-timeout", 1500);
-
-// The read-timeout is a ms timer that causes the transaction to be completely
-// restarted without pipelining.
-pref("network.http.pipelining.read-timeout", 30000);
-
 // Prompt for redirects resulting in unsafe HTTP requests
 pref("network.http.prompt-temp-redirect", false);
 
 // If true generate CORRUPTED_CONTENT errors for entities that
 // contain an invalid Assoc-Req response header
 pref("network.http.assoc-req.enforce", false);
 
 // On networks deploying QoS, it is recommended that these be lockpref()'d,
--- a/netwerk/ipc/NeckoChannelParams.ipdlh
+++ b/netwerk/ipc/NeckoChannelParams.ipdlh
@@ -103,17 +103,16 @@ struct HttpChannelOpenArgs
   uint32_t                    loadFlags;
   RequestHeaderTuples         requestHeaders;
   nsCString                   requestMethod;
   OptionalIPCStream           uploadStream;
   bool                        uploadStreamHasHeaders;
   int16_t                     priority;
   uint32_t                    classOfService;
   uint8_t                     redirectionLimit;
-  bool                        allowPipelining;
   bool                        allowSTS;
   uint32_t                    thirdPartyFlags;
   bool                        resumeAt;
   uint64_t                    startPos;
   nsCString                   entityID;
   bool                        chooseApplicationCache;
   nsCString                   appCacheClientID;
   bool                        allowSpdy;
--- a/netwerk/protocol/http/ConnectionDiagnostics.cpp
+++ b/netwerk/protocol/http/ConnectionDiagnostics.cpp
@@ -60,24 +60,18 @@ nsHttpConnectionMgr::OnMsgPrintDiagnosti
     mLogData.AppendPrintf("   Idle Conns Length = %" PRIuSIZE "\n",
                           ent->mIdleConns.Length());
     mLogData.AppendPrintf("   Half Opens Length = %" PRIuSIZE "\n",
                           ent->mHalfOpens.Length());
     mLogData.AppendPrintf("   Coalescing Keys Length = %" PRIuSIZE "\n",
                           ent->mCoalescingKeys.Length());
     mLogData.AppendPrintf("   Spdy using = %d, preferred = %d\n",
                           ent->mUsingSpdy, ent->mInPreferredHash);
-    mLogData.AppendPrintf("   pipelinestate = %d penalty = %d\n",
-                          ent->mPipelineState, ent->mPipeliningPenalty);
 
     uint32_t i;
-    for (i = 0; i < nsAHttpTransaction::CLASS_MAX; ++i) {
-      mLogData.AppendPrintf("   pipeline per class penalty 0x%x %d\n",
-                            i, ent->mPipeliningClassPenalty[i]);
-    }
     for (i = 0; i < ent->mActiveConns.Length(); ++i) {
       mLogData.AppendPrintf("   :: Active Connection #%u\n", i);
       ent->mActiveConns[i]->PrintDiagnostics(mLogData);
     }
     for (i = 0; i < ent->mIdleConns.Length(); ++i) {
       mLogData.AppendPrintf("   :: Idle Connection #%u\n", i);
       ent->mIdleConns[i]->PrintDiagnostics(mLogData);
     }
@@ -147,19 +141,16 @@ nsHttpConnection::PrintDiagnostics(nsCSt
   log.AppendPrintf("    max-read/read/written %" PRId64 "/%" PRId64 "/%" PRId64 "\n",
                    mMaxBytesRead, mTotalBytesRead, mTotalBytesWritten);
 
   log.AppendPrintf("    rtt = %ums\n", PR_IntervalToMilliseconds(mRtt));
 
   log.AppendPrintf("    idlemonitoring = %d transactionCount=%d\n",
                    mIdleMonitoring, mHttp1xTransactionCount);
 
-  log.AppendPrintf("    supports pipeline = %d classification = 0x%x\n",
-                   mSupportsPipelining, mClassification);
-
   if (mSpdySession)
     mSpdySession->PrintDiagnostics(log);
 }
 
 void
 Http2Session::PrintDiagnostics(nsCString &log)
 {
   log.AppendPrintf("     ::: HTTP2\n");
@@ -202,13 +193,12 @@ nsHttpTransaction::PrintDiagnostics(nsCS
     return;
 
   nsAutoCString requestURI;
   mRequestHead->RequestURI(requestURI);
   log.AppendPrintf("     ::: uri = %s\n", requestURI.get());
   log.AppendPrintf("     caps = 0x%x\n", mCaps);
   log.AppendPrintf("     priority = %d\n", mPriority);
   log.AppendPrintf("     restart count = %u\n", mRestartCount);
-  log.AppendPrintf("     classification = 0x%x\n", mClassification);
 }
 
 } // namespace net
 } // namespace mozilla
--- a/netwerk/protocol/http/Http2Push.cpp
+++ b/netwerk/protocol/http/Http2Push.cpp
@@ -463,40 +463,16 @@ Http2PushTransactionBuffer::SetProxyConn
 void
 Http2PushTransactionBuffer::Close(nsresult reason)
 {
   mStatus = reason;
   mIsDone = true;
 }
 
 nsresult
-Http2PushTransactionBuffer::AddTransaction(nsAHttpTransaction *trans)
-{
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-uint32_t
-Http2PushTransactionBuffer::PipelineDepth()
-{
-  return 0;
-}
-
-nsresult
-Http2PushTransactionBuffer::SetPipelinePosition(int32_t position)
-{
-  return NS_OK;
-}
-
-int32_t
-Http2PushTransactionBuffer::PipelinePosition()
-{
-  return 1;
-}
-
-nsresult
 Http2PushTransactionBuffer::GetBufferedData(char *buf,
                                             uint32_t count,
                                             uint32_t *countWritten)
 {
   *countWritten = std::min(count, static_cast<uint32_t>(Available()));
   if (*countWritten) {
     memcpy(buf, &mBufferedHTTP1[mBufferedHTTP1Consumed], *countWritten);
     mBufferedHTTP1Consumed += *countWritten;
--- a/netwerk/protocol/http/Http2Session.cpp
+++ b/netwerk/protocol/http/Http2Session.cpp
@@ -36,19 +36,17 @@
 #include "sslt.h"
 #include "mozilla/Sprintf.h"
 #include "nsSocketTransportService2.h"
 #include "nsNetUtil.h"
 
 namespace mozilla {
 namespace net {
 
-// Http2Session has multiple inheritance of things that implement
-// nsISupports, so this magic is taken from nsHttpPipeline that
-// implements some of the same abstract classes.
+// Http2Session has multiple inheritance of things that implement nsISupports
 NS_IMPL_ADDREF(Http2Session)
 NS_IMPL_RELEASE(Http2Session)
 NS_INTERFACE_MAP_BEGIN(Http2Session)
 NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsAHttpConnection)
 NS_INTERFACE_MAP_END
 
 // "magic" refers to the string that preceeds HTTP/2 on the wire
 // to help find any intermediaries speaking an older version of HTTP
@@ -3806,31 +3804,16 @@ Http2Session::TakeTransport(nsISocketTra
 
 already_AddRefed<nsHttpConnection>
 Http2Session::TakeHttpConnection()
 {
   MOZ_ASSERT(false, "TakeHttpConnection of Http2Session");
   return nullptr;
 }
 
-uint32_t
-Http2Session::CancelPipeline(nsresult reason)
-{
-  // we don't pipeline inside http/2, so this isn't an issue
-  return 0;
-}
-
-nsAHttpTransaction::Classifier
-Http2Session::Classification()
-{
-  if (!mConnection)
-    return nsAHttpTransaction::CLASS_GENERAL;
-  return mConnection->Classification();
-}
-
 void
 Http2Session::GetSecurityCallbacks(nsIInterfaceRequestor **aOut)
 {
   *aOut = nullptr;
 }
 
 //-----------------------------------------------------------------------------
 // unused methods of nsAHttpTransaction
@@ -3920,52 +3903,16 @@ Http2Session::TakeSubTransactions(
 
     // Removing the stream from the hash will delete the stream and drop the
     // transaction reference the hash held.
     iter.Remove();
   }
   return NS_OK;
 }
 
-nsresult
-Http2Session::AddTransaction(nsAHttpTransaction *)
-{
-  // This API is meant for pipelining, Http2Session's should be
-  // extended with AddStream()
-
-  MOZ_ASSERT(false,
-             "Http2Session::AddTransaction() should not be called");
-
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-uint32_t
-Http2Session::PipelineDepth()
-{
-  return IsDone() ? 0 : 1;
-}
-
-nsresult
-Http2Session::SetPipelinePosition(int32_t position)
-{
-  // This API is meant for pipelining, Http2Session's should be
-  // extended with AddStream()
-
-  MOZ_ASSERT(false,
-             "Http2Session::SetPipelinePosition() should not be called");
-
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-int32_t
-Http2Session::PipelinePosition()
-{
-  return 0;
-}
-
 //-----------------------------------------------------------------------------
 // Pass through methods of nsAHttpConnection
 //-----------------------------------------------------------------------------
 
 nsAHttpConnection *
 Http2Session::Connection()
 {
   MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
--- a/netwerk/protocol/http/HttpBaseChannel.cpp
+++ b/netwerk/protocol/http/HttpBaseChannel.cpp
@@ -157,17 +157,16 @@ HttpBaseChannel::HttpBaseChannel()
   , mPriority(PRIORITY_NORMAL)
   , mRedirectionLimit(gHttpHandler->RedirectionLimit())
   , mApplyConversion(true)
   , mCanceled(false)
   , mIsPending(false)
   , mWasOpened(false)
   , mRequestObserversCalled(false)
   , mResponseHeadersModified(false)
-  , mAllowPipelining(true)
   , mAllowSTS(true)
   , mThirdPartyFlags(0)
   , mUploadStreamHasHeaders(false)
   , mInheritApplicationCache(true)
   , mChooseApplicationCache(false)
   , mLoadedFromApplicationCache(false)
   , mChannelIsForDownload(false)
   , mTracingEnabled(true)
@@ -1949,26 +1948,25 @@ HttpBaseChannel::VisitOriginalResponseHe
   return mResponseHead->VisitHeaders(aVisitor,
       nsHttpHeaderArray::eFilterResponseOriginal);
 }
 
 NS_IMETHODIMP
 HttpBaseChannel::GetAllowPipelining(bool *value)
 {
   NS_ENSURE_ARG_POINTER(value);
-  *value = mAllowPipelining;
+  *value = false;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 HttpBaseChannel::SetAllowPipelining(bool value)
 {
   ENSURE_CALLED_BEFORE_CONNECT();
-
-  mAllowPipelining = value;
+  // nop
   return NS_OK;
 }
 
 NS_IMETHODIMP
 HttpBaseChannel::GetAllowSTS(bool *value)
 {
   NS_ENSURE_ARG_POINTER(value);
   *value = mAllowSTS;
@@ -3227,18 +3225,17 @@ HttpBaseChannel::SetupReplacementChannel
 
     nsAutoCString method;
     mRequestHead.Method(method);
     httpChannel->SetRequestMethod(method);
   }
   // convey the referrer if one was used for this channel to the next one
   if (mReferrer)
     httpChannel->SetReferrerWithPolicy(mReferrer, mReferrerPolicy);
-  // convey the mAllowPipelining and mAllowSTS flags
-  httpChannel->SetAllowPipelining(mAllowPipelining);
+  // convey the mAllowSTS flags
   httpChannel->SetAllowSTS(mAllowSTS);
   // convey the new redirection limit
   // make sure we don't underflow
   uint32_t redirectionLimit = mRedirectionLimit
     ? mRedirectionLimit - 1
     : 0;
   httpChannel->SetRedirectionLimit(redirectionLimit);
 
--- a/netwerk/protocol/http/HttpBaseChannel.h
+++ b/netwerk/protocol/http/HttpBaseChannel.h
@@ -174,18 +174,18 @@ public:
   NS_IMETHOD VisitNonDefaultRequestHeaders(nsIHttpHeaderVisitor *visitor) override;
   NS_IMETHOD GetResponseHeader(const nsACString &header, nsACString &value) override;
   NS_IMETHOD SetResponseHeader(const nsACString& header,
                                const nsACString& value, bool merge) override;
   NS_IMETHOD VisitResponseHeaders(nsIHttpHeaderVisitor *visitor) override;
   NS_IMETHOD GetOriginalResponseHeader(const nsACString &aHeader,
                                        nsIHttpHeaderVisitor *aVisitor) override;
   NS_IMETHOD VisitOriginalResponseHeaders(nsIHttpHeaderVisitor *aVisitor) override;
-  NS_IMETHOD GetAllowPipelining(bool *value) override;
-  NS_IMETHOD SetAllowPipelining(bool value) override;
+  NS_IMETHOD GetAllowPipelining(bool *value) override; // deprecated
+  NS_IMETHOD SetAllowPipelining(bool value) override;  // deprecated
   NS_IMETHOD GetAllowSTS(bool *value) override;
   NS_IMETHOD SetAllowSTS(bool value) override;
   NS_IMETHOD GetRedirectionLimit(uint32_t *value) override;
   NS_IMETHOD SetRedirectionLimit(uint32_t value) override;
   NS_IMETHOD IsNoStoreResponse(bool *value) override;
   NS_IMETHOD IsNoCacheResponse(bool *value) override;
   NS_IMETHOD IsPrivateResponse(bool *value) override;
   NS_IMETHOD GetResponseStatus(uint32_t *aValue) override;
@@ -482,17 +482,16 @@ protected:
 
   uint32_t                          mApplyConversion            : 1;
   uint32_t                          mCanceled                   : 1;
   uint32_t                          mIsPending                  : 1;
   uint32_t                          mWasOpened                  : 1;
   // if 1 all "http-on-{opening|modify|etc}-request" observers have been called
   uint32_t                          mRequestObserversCalled     : 1;
   uint32_t                          mResponseHeadersModified    : 1;
-  uint32_t                          mAllowPipelining            : 1;
   uint32_t                          mAllowSTS                   : 1;
   uint32_t                          mThirdPartyFlags            : 3;
   uint32_t                          mUploadStreamHasHeaders     : 1;
   uint32_t                          mInheritApplicationCache    : 1;
   uint32_t                          mChooseApplicationCache     : 1;
   uint32_t                          mLoadedFromApplicationCache : 1;
   uint32_t                          mChannelIsForDownload       : 1;
   uint32_t                          mTracingEnabled             : 1;
--- a/netwerk/protocol/http/HttpChannelChild.cpp
+++ b/netwerk/protocol/http/HttpChannelChild.cpp
@@ -2185,17 +2185,16 @@ HttpChannelChild::ContinueAsyncOpen()
   SerializeURI(mTopWindowURI, openArgs.topWindowURI());
 
   openArgs.preflightArgs() = optionalCorsPreflightArgs;
 
   openArgs.uploadStreamHasHeaders() = mUploadStreamHasHeaders;
   openArgs.priority() = mPriority;
   openArgs.classOfService() = mClassOfService;
   openArgs.redirectionLimit() = mRedirectionLimit;
-  openArgs.allowPipelining() = mAllowPipelining;
   openArgs.allowSTS() = mAllowSTS;
   openArgs.thirdPartyFlags() = mThirdPartyFlags;
   openArgs.resumeAt() = mSendResumeAt;
   openArgs.startPos() = mStartPos;
   openArgs.entityID() = mEntityID;
   openArgs.chooseApplicationCache() = mChooseApplicationCache;
   openArgs.appCacheClientID() = appCacheClientId;
   openArgs.allowSpdy() = mAllowSpdy;
--- a/netwerk/protocol/http/HttpChannelParent.cpp
+++ b/netwerk/protocol/http/HttpChannelParent.cpp
@@ -115,17 +115,17 @@ HttpChannelParent::Init(const HttpChanne
   case HttpChannelCreationArgs::THttpChannelOpenArgs:
   {
     const HttpChannelOpenArgs& a = aArgs.get_HttpChannelOpenArgs();
     return DoAsyncOpen(a.uri(), a.original(), a.doc(), a.referrer(),
                        a.referrerPolicy(), a.apiRedirectTo(), a.topWindowURI(),
                        a.loadFlags(), a.requestHeaders(),
                        a.requestMethod(), a.uploadStream(),
                        a.uploadStreamHasHeaders(), a.priority(), a.classOfService(),
-                       a.redirectionLimit(), a.allowPipelining(), a.allowSTS(),
+                       a.redirectionLimit(), a.allowSTS(),
                        a.thirdPartyFlags(), a.resumeAt(), a.startPos(),
                        a.entityID(), a.chooseApplicationCache(),
                        a.appCacheClientID(), a.allowSpdy(), a.allowAltSvc(), a.beConservative(),
                        a.loadInfo(), a.synthesizedResponseHead(),
                        a.synthesizedSecurityInfoSerialization(),
                        a.cacheKey(), a.requestContextID(), a.preflightArgs(),
                        a.initialRwin(), a.blockAuthPrompt(),
                        a.suspendAfterSynthesizeResponse(),
@@ -300,17 +300,16 @@ HttpChannelParent::DoAsyncOpen(  const U
                                  const uint32_t&            aLoadFlags,
                                  const RequestHeaderTuples& requestHeaders,
                                  const nsCString&           requestMethod,
                                  const OptionalIPCStream&   uploadStream,
                                  const bool&                uploadStreamHasHeaders,
                                  const int16_t&             priority,
                                  const uint32_t&            classOfService,
                                  const uint8_t&             redirectionLimit,
-                                 const bool&                allowPipelining,
                                  const bool&                allowSTS,
                                  const uint32_t&            thirdPartyFlags,
                                  const bool&                doResumeAt,
                                  const uint64_t&            startPos,
                                  const nsCString&           entityID,
                                  const bool&                chooseApplicationCache,
                                  const nsCString&           appCacheClientID,
                                  const bool&                allowSpdy,
@@ -521,17 +520,16 @@ HttpChannelParent::DoAsyncOpen(  const U
 
   if (priority != nsISupportsPriority::PRIORITY_NORMAL) {
     mChannel->SetPriority(priority);
   }
   if (classOfService) {
     mChannel->SetClassFlags(classOfService);
   }
   mChannel->SetRedirectionLimit(redirectionLimit);
-  mChannel->SetAllowPipelining(allowPipelining);
   mChannel->SetAllowSTS(allowSTS);
   mChannel->SetThirdPartyFlags(thirdPartyFlags);
   mChannel->SetAllowSpdy(allowSpdy);
   mChannel->SetAllowAltSvc(allowAltSvc);
   mChannel->SetBeConservative(beConservative);
   mChannel->SetInitialRwin(aInitialRwin);
   mChannel->SetBlockAuthPrompt(aBlockAuthPrompt);
 
--- a/netwerk/protocol/http/HttpChannelParent.h
+++ b/netwerk/protocol/http/HttpChannelParent.h
@@ -117,17 +117,16 @@ protected:
                    const uint32_t&            loadFlags,
                    const RequestHeaderTuples& requestHeaders,
                    const nsCString&           requestMethod,
                    const OptionalIPCStream&   uploadStream,
                    const bool&                uploadStreamHasHeaders,
                    const int16_t&             priority,
                    const uint32_t&            classOfService,
                    const uint8_t&             redirectionLimit,
-                   const bool&                allowPipelining,
                    const bool&                allowSTS,
                    const uint32_t&            thirdPartyFlags,
                    const bool&                doResumeAt,
                    const uint64_t&            startPos,
                    const nsCString&           entityID,
                    const bool&                chooseApplicationCache,
                    const nsCString&           appCacheClientID,
                    const bool&                allowSpdy,
--- a/netwerk/protocol/http/NullHttpTransaction.cpp
+++ b/netwerk/protocol/http/NullHttpTransaction.cpp
@@ -299,35 +299,11 @@ NullHttpTransaction::Close(nsresult reas
 }
 
 nsHttpConnectionInfo *
 NullHttpTransaction::ConnectionInfo()
 {
   return mConnectionInfo;
 }
 
-nsresult
-NullHttpTransaction::AddTransaction(nsAHttpTransaction *trans)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-uint32_t
-NullHttpTransaction::PipelineDepth()
-{
-  return 0;
-}
-
-nsresult
-NullHttpTransaction::SetPipelinePosition(int32_t position)
-{
-    return NS_OK;
-}
-
-int32_t
-NullHttpTransaction::PipelinePosition()
-{
-  return 1;
-}
-
 } // namespace net
 } // namespace mozilla
 
--- a/netwerk/protocol/http/TunnelUtils.cpp
+++ b/netwerk/protocol/http/TunnelUtils.cpp
@@ -684,69 +684,16 @@ TLSFilterTransaction::SetProxiedTransact
   nsCOMPtr<nsISSLSocketControl> secCtrl(do_QueryInterface(mSecInfo));
   if (secCtrl && callbacks) {
     secCtrl->SetNotificationCallbacks(callbacks);
   }
 
   return NS_OK;
 }
 
-// AddTransaction is for adding pipelined subtransactions
-nsresult
-TLSFilterTransaction::AddTransaction(nsAHttpTransaction *aTrans)
-{
-  LOG(("TLSFilterTransaction::AddTransaction passing on subtransaction "
-       "[this=%p] aTrans=%p ,mTransaction=%p\n", this, aTrans, mTransaction.get()));
-
-  if (!mTransaction) {
-    return NS_ERROR_FAILURE;
-  }
-
-  return mTransaction->AddTransaction(aTrans);
-}
-
-uint32_t
-TLSFilterTransaction::PipelineDepth()
-{
-  if (!mTransaction) {
-    return 0;
-  }
-
-  return mTransaction->PipelineDepth();
-}
-
-nsresult
-TLSFilterTransaction::SetPipelinePosition(int32_t aPosition)
-{
-  if (!mTransaction) {
-    return NS_OK;
-  }
-
-  return mTransaction->SetPipelinePosition(aPosition);
-}
-
-int32_t
-TLSFilterTransaction::PipelinePosition()
-{
-  if (!mTransaction) {
-    return 1;
-  }
-
-  return mTransaction->PipelinePosition();
-}
-
-nsHttpPipeline *
-TLSFilterTransaction::QueryPipeline()
-{
-  if (!mTransaction) {
-    return nullptr;
-  }
-  return mTransaction->QueryPipeline();
-}
-
 bool
 TLSFilterTransaction::IsNullTransaction()
 {
   if (!mTransaction) {
     return false;
   }
   return mTransaction->IsNullTransaction();
 }
--- a/netwerk/protocol/http/TunnelUtils.h
+++ b/netwerk/protocol/http/TunnelUtils.h
@@ -123,17 +123,16 @@ public:
   nsresult NudgeTunnel(NudgeTunnelCallback *callback);
   nsresult SetProxiedTransaction(nsAHttpTransaction *aTrans);
   void     newIODriver(nsIAsyncInputStream *aSocketIn,
                        nsIAsyncOutputStream *aSocketOut,
                        nsIAsyncInputStream **outSocketIn,
                        nsIAsyncOutputStream **outSocketOut);
 
   // nsAHttpTransaction overloads
-  nsHttpPipeline *QueryPipeline() override;
   bool IsNullTransaction() override;
   NullHttpTransaction *QueryNullTransaction() override;
   nsHttpTransaction *QueryHttpTransaction() override;
   SpdyConnectTransaction *QuerySpdyConnectTransaction() override;
 
 private:
   nsresult StartTimerCallback();
   void Cleanup();
--- a/netwerk/protocol/http/moz.build
+++ b/netwerk/protocol/http/moz.build
@@ -83,17 +83,16 @@ UNIFIED_SOURCES += [
     'nsHttpChannel.cpp',
     'nsHttpChunkedDecoder.cpp',
     'nsHttpConnection.cpp',
     'nsHttpConnectionInfo.cpp',
     'nsHttpConnectionMgr.cpp',
     'nsHttpDigestAuth.cpp',
     'nsHttpHeaderArray.cpp',
     'nsHttpNTLMAuth.cpp',
-    'nsHttpPipeline.cpp',
     'nsHttpRequestHead.cpp',
     'nsHttpResponseHead.cpp',
     'nsHttpTransaction.cpp',
     'NullHttpChannel.cpp',
     'NullHttpTransaction.cpp',
     'TunnelUtils.cpp',
 ]
 
--- a/netwerk/protocol/http/nsAHttpConnection.h
+++ b/netwerk/protocol/http/nsAHttpConnection.h
@@ -57,18 +57,18 @@ public:
     // called by a transaction to force a "send/recv from network" iteration
     // even if not scheduled by socket associated with connection
     virtual nsresult ForceSend() = 0;
     virtual nsresult ForceRecv() = 0;
 
     // After a connection has had ResumeSend() called by a transaction,
     // and it is ready to write to the network it may need to know the
     // transaction that has data to write. This is only an issue for
-    // multiplexed protocols like SPDY - plain HTTP or pipelined HTTP
-    // implicitly have this information in a 1:1 relationship with the
+    // multiplexed protocols like SPDY - h1
+    // implicitly has this information in a 1:1 relationship with the
     // transaction(s) they manage.
     virtual void TransactionHasDataToWrite(nsAHttpTransaction *)
     {
         // by default do nothing - only multiplexed protocols need to overload
         return;
     }
 
     // This is the companion to *HasDataToWrite() for the case
@@ -107,17 +107,17 @@ public:
     // persistent... important in determining the end of a response.
     virtual bool IsPersistent() = 0;
 
     // called to determine or set if a connection has been reused.
     virtual bool IsReused() = 0;
     virtual void DontReuse() = 0;
 
     // called by a transaction when the transaction reads more from the socket
-    // than it should have (eg. containing part of the next pipelined response).
+    // than it should have (eg. containing part of the next response).
     virtual nsresult PushBack(const char *data, uint32_t length) = 0;
 
     // Used to determine if the connection wants read events even though
     // it has not written out a transaction. Used when a connection has issued
     // a preamble such as a proxy ssl CONNECT sequence.
     virtual bool IsProxyConnectInProgress() = 0;
 
     // Used by a transaction to manage the state of previous response bodies on
@@ -128,24 +128,16 @@ public:
     // Transfer the base http connection object along with a
     // reference to it to the caller.
     virtual already_AddRefed<nsHttpConnection> TakeHttpConnection() = 0;
 
     // Get the nsISocketTransport used by the connection without changing
     //  references or ownership.
     virtual nsISocketTransport *Transport() = 0;
 
-    // Cancel and reschedule transactions deeper than the current response.
-    // Returns the number of canceled transactions.
-    virtual uint32_t CancelPipeline(nsresult originalReason) = 0;
-
-    // Read and write class of transaction that is carried on this connection
-    virtual nsAHttpTransaction::Classifier Classification() = 0;
-    virtual void Classify(nsAHttpTransaction::Classifier newclass) = 0;
-
     // The number of transaction bytes written out on this HTTP Connection, does
     // not count CONNECT tunnel setup
     virtual int64_t BytesWritten() = 0;
 
     // Update the callbacks used to provide security info. May be called on
     // any thread.
     virtual void SetSecurityCallbacks(nsIInterfaceRequestor* aCallbacks) = 0;
 
@@ -161,18 +153,16 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpCon
     nsresult TakeTransport(nsISocketTransport **,    \
                            nsIAsyncInputStream **,   \
                            nsIAsyncOutputStream **) override; \
     bool IsPersistent() override;                         \
     bool IsReused() override;                             \
     void DontReuse() override;                            \
     nsresult PushBack(const char *, uint32_t) override;   \
     already_AddRefed<nsHttpConnection> TakeHttpConnection() override; \
-    uint32_t CancelPipeline(nsresult originalReason) override; \
-    nsAHttpTransaction::Classifier Classification() override; \
     /*                                                    \
        Thes methods below have automatic definitions that just forward the \
        function to a lower level connection object        \
     */                                                    \
     void GetConnectionInfo(nsHttpConnectionInfo **result) \
       override                                            \
     {                                                     \
       if (!(fwdObject)) {                                 \
@@ -237,22 +227,16 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpCon
         (fwdObject)->LastTransactionExpectedNoContent();    \
     }                                                       \
     void SetLastTransactionExpectedNoContent(bool val)      \
       override                                              \
     {                                                       \
       if (fwdObject)                                        \
         (fwdObject)->SetLastTransactionExpectedNoContent(val); \
     }                                                       \
-    void Classify(nsAHttpTransaction::Classifier newclass)  \
-      override                                              \
-    {                                                       \
-    if (fwdObject)                                          \
-        (fwdObject)->Classify(newclass);                    \
-    }                                                       \
     int64_t BytesWritten() override                         \
     {     return fwdObject ? (fwdObject)->BytesWritten() : 0; } \
     void SetSecurityCallbacks(nsIInterfaceRequestor* aCallbacks) \
       override                                              \
     {                                                       \
         if (fwdObject)                                      \
             (fwdObject)->SetSecurityCallbacks(aCallbacks);  \
     }
--- a/netwerk/protocol/http/nsAHttpTransaction.h
+++ b/netwerk/protocol/http/nsAHttpTransaction.h
@@ -14,17 +14,16 @@ class nsITransport;
 class nsIRequestContext;
 
 namespace mozilla { namespace net {
 
 class nsAHttpConnection;
 class nsAHttpSegmentReader;
 class nsAHttpSegmentWriter;
 class nsHttpTransaction;
-class nsHttpPipeline;
 class nsHttpRequestHead;
 class nsHttpConnectionInfo;
 class NullHttpTransaction;
 class SpdyConnectTransaction;
 
 //----------------------------------------------------------------------------
 // Abstract base class for a HTTP transaction:
 //
@@ -95,58 +94,38 @@ public:
 
     // called to indicate a failure with proxy CONNECT
     virtual void SetProxyConnectFailed() = 0;
 
     // called to retrieve the request headers of the transaction
     virtual nsHttpRequestHead *RequestHead() = 0;
 
     // determine the number of real http/1.x transactions on this
-    // abstract object. Pipelines may have multiple, SPDY has 0,
+    // abstract object. Pipelines had multiple, SPDY has 0,
     // normal http transactions have 1.
     virtual uint32_t Http1xTransactionCount() = 0;
 
     // called to remove the unused sub transactions from an object that can
-    // handle multiple transactions simultaneously (i.e. pipelines or spdy).
+    // handle multiple transactions simultaneously (i.e. h2).
     //
     // Returns NS_ERROR_NOT_IMPLEMENTED if the object does not implement
     // sub-transactions.
     //
     // Returns NS_ERROR_ALREADY_OPENED if the subtransactions have been
     // at least partially written and cannot be moved.
     //
     virtual nsresult TakeSubTransactions(
         nsTArray<RefPtr<nsAHttpTransaction> > &outTransactions) = 0;
 
-    // called to add a sub-transaction in the case of pipelined transactions
-    // classes that do not implement sub transactions
-    // return NS_ERROR_NOT_IMPLEMENTED
-    virtual nsresult AddTransaction(nsAHttpTransaction *transaction) = 0;
-
-    // The total length of the outstanding pipeline comprised of transacations
-    // and sub-transactions.
-    virtual uint32_t PipelineDepth() = 0;
-
-    // Used to inform the connection that it is being used in a pipelined
-    // context. That may influence the handling of some errors.
-    // The value is the pipeline position (> 1).
-    virtual nsresult SetPipelinePosition(int32_t) = 0;
-    virtual int32_t  PipelinePosition() = 0;
-
     // Occasionally the abstract interface has to give way to base implementations
-    // to respect differences between spdy, pipelines, etc..
+    // to respect differences between spdy, h2, etc..
     // These Query* (and IsNullTransaction()) functions provide a way to do
     // that without using xpcom or rtti. Any calling code that can't deal with
     // a null response from one of them probably shouldn't be using nsAHttpTransaction
 
-    // If we used rtti this would be the result of doing
-    // dynamic_cast<nsHttpPipeline *>(this).. i.e. it can be nullptr for
-    // non pipeline implementations of nsAHttpTransaction
-    virtual nsHttpPipeline *QueryPipeline() { return nullptr; }
-
     // equivalent to !!dynamic_cast<NullHttpTransaction *>(this)
     // A null transaction is expected to return BASE_STREAM_CLOSED on all of
     // its IO functions all the time.
     virtual bool IsNullTransaction() { return false; }
     virtual NullHttpTransaction *QueryNullTransaction() { return nullptr; }
 
     // If we used rtti this would be the result of doing
     // dynamic_cast<nsHttpTransaction *>(this).. i.e. it can be nullptr for
@@ -163,39 +142,16 @@ public:
 
     // return the connection information associated with the transaction
     virtual nsHttpConnectionInfo *ConnectionInfo() = 0;
 
     // The base definition of these is done in nsHttpTransaction.cpp
     virtual bool ResponseTimeoutEnabled() const;
     virtual PRIntervalTime ResponseTimeout();
 
-    // Every transaction is classified into one of the types below. When using
-    // HTTP pipelines, only transactions with the same type appear on the same
-    // pipeline.
-    enum Classifier  {
-        // Transactions that expect a short 304 (no-content) response
-        CLASS_REVALIDATION,
-
-        // Transactions for content expected to be CSS or JS
-        CLASS_SCRIPT,
-
-        // Transactions for content expected to be an image
-        CLASS_IMAGE,
-
-        // Transactions that cannot involve a pipeline
-        CLASS_SOLO,
-
-        // Transactions that do not fit any of the other categories. HTML
-        // is normally GENERAL.
-        CLASS_GENERAL,
-
-        CLASS_MAX
-    };
-
     // conceptually the security info is part of the connection, but sometimes
     // in the case of TLS tunneled within TLS the transaction might present
     // a more specific security info that cannot be represented as a layer in
     // the connection due to multiplexing. This interface represents such an
     // overload. If it returns NS_FAILURE the connection should be considered
     // authoritative.
     virtual nsresult GetTransactionSecurityInfo(nsISupports **)
     {
@@ -240,21 +196,17 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpTra
     uint64_t Available() override; \
     virtual nsresult ReadSegments(nsAHttpSegmentReader *, uint32_t, uint32_t *) override; \
     virtual nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t, uint32_t *) override; \
     virtual void Close(nsresult reason) override;                                \
     nsHttpConnectionInfo *ConnectionInfo() override;                             \
     void     SetProxyConnectFailed() override;                                   \
     virtual nsHttpRequestHead *RequestHead() override;                                   \
     uint32_t Http1xTransactionCount() override;                                  \
-    nsresult TakeSubTransactions(nsTArray<RefPtr<nsAHttpTransaction> > &outTransactions) override; \
-    nsresult AddTransaction(nsAHttpTransaction *) override;                      \
-    uint32_t PipelineDepth() override;                                           \
-    nsresult SetPipelinePosition(int32_t) override;                              \
-    int32_t  PipelinePosition() override;
+    nsresult TakeSubTransactions(nsTArray<RefPtr<nsAHttpTransaction> > &outTransactions) override;
 
 //-----------------------------------------------------------------------------
 // nsAHttpSegmentReader
 //-----------------------------------------------------------------------------
 
 class nsAHttpSegmentReader
 {
 public:
--- a/netwerk/protocol/http/nsHttp.h
+++ b/netwerk/protocol/http/nsHttp.h
@@ -46,17 +46,17 @@ namespace net {
 
 typedef uint8_t nsHttpVersion;
 
 //-----------------------------------------------------------------------------
 // http connection capabilities
 //-----------------------------------------------------------------------------
 
 #define NS_HTTP_ALLOW_KEEPALIVE      (1<<0)
-#define NS_HTTP_ALLOW_PIPELINING     (1<<1)
+// NS_HTTP_ALLOW_PIPELINING          (1<<1) removed
 
 // a transaction with this caps flag will continue to own the connection,
 // preventing it from being reclaimed, even after the transaction completes.
 #define NS_HTTP_STICKY_CONNECTION    (1<<2)
 
 // a transaction with this caps flag will, upon opening a new connection,
 // bypass the local DNS cache
 #define NS_HTTP_REFRESH_DNS          (1<<3)
--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@@ -793,62 +793,26 @@ nsHttpChannel::SetupTransactionRequestCo
 
     if (NS_FAILED(rv)) {
         return;
     }
 
     mTransaction->SetRequestContext(rc);
 }
 
-static bool
-SafeForPipelining(nsHttpRequestHead::ParsedMethodType method,
-                  const nsCString &methodString)
-{
-    if (method == nsHttpRequestHead::kMethod_Get ||
-        method == nsHttpRequestHead::kMethod_Head ||
-        method == nsHttpRequestHead::kMethod_Options) {
-        return true;
-    }
-
-    if (method != nsHttpRequestHead::kMethod_Custom) {
-        return false;
-    }
-
-    return (!strcmp(methodString.get(), "PROPFIND") ||
-            !strcmp(methodString.get(), "PROPPATCH"));
-}
-
 nsresult
 nsHttpChannel::SetupTransaction()
 {
     LOG(("nsHttpChannel::SetupTransaction [this=%p]\n", this));
 
     NS_ENSURE_TRUE(!mTransaction, NS_ERROR_ALREADY_INITIALIZED);
 
     nsresult rv;
 
     mUsedNetwork = 1;
-    if (mCaps & NS_HTTP_ALLOW_PIPELINING) {
-        //
-        // disable pipelining if:
-        //   (1) pipelining has been disabled by config
-        //   (2) pipelining has been disabled by connection mgr info
-        //   (3) request corresponds to a top-level document load (link click)
-        //   (4) request method is non-idempotent
-        //   (5) request is marked slow (e.g XHR)
-        //
-        nsAutoCString method;
-        mRequestHead.Method(method);
-        if (!mAllowPipelining ||
-           (mLoadFlags & (LOAD_INITIAL_DOCUMENT_URI | INHIBIT_PIPELINE)) ||
-            !SafeForPipelining(mRequestHead.ParsedMethod(), method)) {
-            LOG(("  pipelining disallowed\n"));
-            mCaps &= ~NS_HTTP_ALLOW_PIPELINING;
-        }
-    }
 
     if (!mAllowSpdy) {
         mCaps |= NS_HTTP_DISALLOW_SPDY;
     }
     if (mBeConservative) {
         mCaps |= NS_HTTP_BE_CONSERVATIVE;
     }
 
@@ -986,17 +950,16 @@ nsHttpChannel::SetupTransaction()
         mCaps |= NS_HTTP_TIMING_ENABLED;
 
     if (mUpgradeProtocolCallback) {
         mRequestHead.SetHeader(nsHttp::Upgrade, mUpgradeProtocol, false);
         mRequestHead.SetHeaderOnce(nsHttp::Connection,
                                    nsHttp::Upgrade.get(),
                                    true);
         mCaps |=  NS_HTTP_STICKY_CONNECTION;
-        mCaps &= ~NS_HTTP_ALLOW_PIPELINING;
         mCaps &= ~NS_HTTP_ALLOW_KEEPALIVE;
     }
 
     if (mPushedStream) {
         mTransaction->SetPushedStream(mPushedStream);
         mPushedStream = nullptr;
     }
 
@@ -1399,20 +1362,16 @@ nsHttpChannel::CallOnStartRequest()
         return rv;
       }
       if (listener) {
         mListener = listener;
         mCompressListener = listener;
       }
     }
 
-    rv = EnsureAssocReq();
-    if (NS_FAILED(rv))
-        return rv;
-
     // if this channel is for a download, close off access to the cache.
     if (mCacheEntry && mChannelIsForDownload) {
         mCacheEntry->AsyncDoom(nullptr);
 
         // We must keep the cache entry in case of partial request.
         // Concurrent access is the same, we need the entry in
         // OnStopRequest.
         if (!mCachedContentIsPartial && !mConcurrentCacheAccess)
@@ -2913,130 +2872,16 @@ nsHttpChannel::ResponseWouldVary(nsICach
 // to set a member function ptr to  a base class function.
 void
 nsHttpChannel::HandleAsyncAbort()
 {
     HttpAsyncAborter<nsHttpChannel>::HandleAsyncAbort();
 }
 
 
-nsresult
-nsHttpChannel::EnsureAssocReq()
-{
-    // Confirm Assoc-Req response header on pipelined transactions
-    // per draft-nottingham-http-pipeline-01.txt
-    // of the form: GET http://blah.com/foo/bar?qv
-    // return NS_OK as long as we don't find a violation
-    // (i.e. no header is ok, as are malformed headers, as are
-    // transactions that have not been pipelined (unless those have been
-    // opted in via pragma))
-
-    if (!mResponseHead)
-        return NS_OK;
-
-    nsAutoCString assoc_val;
-    if (NS_FAILED(mResponseHead->GetHeader(nsHttp::Assoc_Req, assoc_val))) {
-        return NS_OK;
-    }
-
-    if (!mTransaction || !mURI)
-        return NS_OK;
-
-    if (!mTransaction->PipelinePosition()) {
-        // "Pragma: X-Verify-Assoc-Req" can be used to verify even non pipelined
-        // transactions. It is used by test harness.
-
-        nsAutoCString pragma_val;
-        mResponseHead->GetHeader(nsHttp::Pragma, pragma_val);
-        if (pragma_val.IsEmpty() ||
-            !nsHttp::FindToken(pragma_val.get(), "X-Verify-Assoc-Req",
-                               HTTP_HEADER_VALUE_SEPS))
-            return NS_OK;
-    }
-
-    char *method = net_FindCharNotInSet(assoc_val.get(), HTTP_LWS);
-    if (!method)
-        return NS_OK;
-
-    bool equals;
-    char *endofmethod;
-
-    char * assoc_valChar = nullptr;
-    endofmethod = net_FindCharInSet(method, HTTP_LWS);
-    if (endofmethod)
-        assoc_valChar = net_FindCharNotInSet(endofmethod, HTTP_LWS);
-    if (!assoc_valChar)
-        return NS_OK;
-
-    // check the method
-    nsAutoCString methodHead;
-    mRequestHead.Method(methodHead);
-    if ((((int32_t)methodHead.Length()) != (endofmethod - method)) ||
-        PL_strncmp(method,
-                   methodHead.get(),
-                   endofmethod - method)) {
-        LOG(("  Assoc-Req failure Method %s", method));
-        if (mConnectionInfo)
-            gHttpHandler->ConnMgr()->
-                PipelineFeedbackInfo(mConnectionInfo,
-                                     nsHttpConnectionMgr::RedCorruptedContent,
-                                     nullptr, 0);
-
-        nsCOMPtr<nsIConsoleService> consoleService =
-            do_GetService(NS_CONSOLESERVICE_CONTRACTID);
-        if (consoleService) {
-            nsAutoString message
-                (NS_LITERAL_STRING("Failed Assoc-Req. Received "));
-            nsAutoCString assoc_req;
-            mResponseHead->GetHeader(nsHttp::Assoc_Req, assoc_req);
-            AppendASCIItoUTF16(assoc_req, message);
-            message += NS_LITERAL_STRING(" expected method ");
-            AppendASCIItoUTF16(methodHead, message);
-            consoleService->LogStringMessage(message.get());
-        }
-
-        if (gHttpHandler->EnforceAssocReq())
-            return NS_ERROR_CORRUPTED_CONTENT;
-        return NS_OK;
-    }
-
-    // check the URL
-    nsCOMPtr<nsIURI> assoc_url;
-    if (NS_FAILED(NS_NewURI(getter_AddRefs(assoc_url), assoc_valChar)) ||
-        !assoc_url)
-        return NS_OK;
-
-    mURI->Equals(assoc_url, &equals);
-    if (!equals) {
-        LOG(("  Assoc-Req failure URL %s", assoc_valChar));
-        if (mConnectionInfo)
-            gHttpHandler->ConnMgr()->
-                PipelineFeedbackInfo(mConnectionInfo,
-                                     nsHttpConnectionMgr::RedCorruptedContent,
-                                     nullptr, 0);
-
-        nsCOMPtr<nsIConsoleService> consoleService =
-            do_GetService(NS_CONSOLESERVICE_CONTRACTID);
-        if (consoleService) {
-            nsAutoString message
-                (NS_LITERAL_STRING("Failed Assoc-Req. Received "));
-            nsAutoCString assoc_req;
-            mResponseHead->GetHeader(nsHttp::Assoc_Req, assoc_req);
-            AppendASCIItoUTF16(assoc_req, message);
-            message += NS_LITERAL_STRING(" expected URL ");
-            AppendASCIItoUTF16(mSpec.get(), message);
-            consoleService->LogStringMessage(message.get());
-        }
-
-        if (gHttpHandler->EnforceAssocReq())
-            return NS_ERROR_CORRUPTED_CONTENT;
-    }
-    return NS_OK;
-}
-
 //-----------------------------------------------------------------------------
 // nsHttpChannel <byte-range>
 //-----------------------------------------------------------------------------
 
 bool
 nsHttpChannel::IsResumable(int64_t partialLen, int64_t contentLength,
                            bool ignoreMissingPartialLen) const
 {
@@ -3306,17 +3151,17 @@ nsHttpChannel::ProcessNotModified()
     MOZ_ASSERT(mCacheEntry);
     NS_ENSURE_TRUE(mCachedResponseHead && mCacheEntry, NS_ERROR_UNEXPECTED);
 
     // If the 304 response contains a Last-Modified different than the
     // one in our cache that is pretty suspicious and is, in at least the
     // case of bug 716840, a sign of the server having previously corrupted
     // our cache with a bad response. Take the minor step here of just dooming
     // that cache entry so there is a fighting chance of getting things on the
-    // right track as well as disabling pipelining for that host.
+    // right track.
 
     nsAutoCString lastModifiedCached;
     nsAutoCString lastModified304;
 
     rv = mCachedResponseHead->GetHeader(nsHttp::Last_Modified,
                                         lastModifiedCached);
     if (NS_SUCCEEDED(rv)) {
         rv = mResponseHead->GetHeader(nsHttp::Last_Modified,
@@ -3324,21 +3169,16 @@ nsHttpChannel::ProcessNotModified()
     }
 
     if (NS_SUCCEEDED(rv) && !lastModified304.Equals(lastModifiedCached)) {
         LOG(("Cache Entry and 304 Last-Modified Headers Do Not Match "
              "[%s] and [%s]\n",
              lastModifiedCached.get(), lastModified304.get()));
 
         mCacheEntry->AsyncDoom(nullptr);
-        if (mConnectionInfo)
-            gHttpHandler->ConnMgr()->
-                PipelineFeedbackInfo(mConnectionInfo,
-                                     nsHttpConnectionMgr::RedCorruptedContent,
-                                     nullptr, 0);
         Telemetry::Accumulate(Telemetry::CACHE_LM_INCONSISTENT, true);
     }
 
     // merge any new headers with the cached response headers
     rv = mCachedResponseHead->UpdateHeaders(mResponseHead);
     if (NS_FAILED(rv)) return rv;
 
     // update the cached response head
@@ -6144,23 +5984,16 @@ nsHttpChannel::BeginConnect()
         }
     }
 
     // If mTimingEnabled flag is not set after OnModifyRequest() then
     // clear the already recorded AsyncOpen value for consistency.
     if (!mTimingEnabled)
         mAsyncOpenTime = TimeStamp();
 
-    // when proxying only use the pipeline bit if ProxyPipelining() allows it.
-    if (!mConnectionInfo->UsingConnect() && mConnectionInfo->UsingHttpProxy()) {
-        mCaps &= ~NS_HTTP_ALLOW_PIPELINING;
-        if (gHttpHandler->ProxyPipelining())
-            mCaps |= NS_HTTP_ALLOW_PIPELINING;
-    }
-
     // if this somehow fails we can go on without it
     gHttpHandler->AddConnectionHeader(&mRequestHead, mCaps);
 
     if (mLoadFlags & VALIDATE_ALWAYS || BYPASS_LOCAL_CACHE(mLoadFlags))
         mCaps |= NS_HTTP_REFRESH_DNS;
 
     if (!mLocalBlocklist && !mConnectionInfo->UsingHttpProxy() &&
         !(mLoadFlags & (LOAD_NO_NETWORK_IO | LOAD_ONLY_FROM_CACHE))) {
@@ -6182,17 +6015,17 @@ nsHttpChannel::BeginConnect()
         mDNSPrefetch = new nsDNSPrefetch(mURI, this, mTimingEnabled);
         mDNSPrefetch->PrefetchHigh(mCaps & NS_HTTP_REFRESH_DNS);
     }
 
     // Adjust mCaps according to our request headers:
     //  - If "Connection: close" is set as a request header, then do not bother
     //    trying to establish a keep-alive connection.
     if (mRequestHead.HasHeaderValue(nsHttp::Connection, "close"))
-        mCaps &= ~(NS_HTTP_ALLOW_KEEPALIVE | NS_HTTP_ALLOW_PIPELINING);
+        mCaps &= ~(NS_HTTP_ALLOW_KEEPALIVE);
 
     if (gHttpHandler->CriticalRequestPrioritization()) {
         if (mClassOfService & nsIClassOfService::Leader) {
             mCaps |= NS_HTTP_LOAD_AS_BLOCKING;
         }
         if (mClassOfService & nsIClassOfService::Unblocked) {
             mCaps |= NS_HTTP_LOAD_UNBLOCKED;
         }
@@ -6200,17 +6033,16 @@ nsHttpChannel::BeginConnect()
 
     // Force-Reload should reset the persistent connection pool for this host
     if (mLoadFlags & LOAD_FRESH_CONNECTION) {
         // just the initial document resets the whole pool
         if (mLoadFlags & LOAD_INITIAL_DOCUMENT_URI) {
             gHttpHandler->ConnMgr()->ClearAltServiceMappings();
             gHttpHandler->ConnMgr()->DoShiftReloadConnectionCleanup(mConnectionInfo);
         }
-        mCaps &= ~NS_HTTP_ALLOW_PIPELINING;
     }
 
     // We may have been cancelled already, either by on-modify-request
     // listeners or load group observers; in that case, we should not send the
     // request to the server
     if (mCanceled) {
         return mStatus;
     }
@@ -6872,24 +6704,16 @@ nsHttpChannel::OnStopRequest(nsIRequest 
             LOG(("  transaction %p provides connection %p", mTransaction.get(), conn.get()));
             // This is so far a workaround to fix leak when reusing unpersistent
             // connection for authentication retry. See bug 459620 comment 4
             // for details.
             if (conn && !conn->IsPersistent()) {
                 LOG(("  connection is not persistent, not reusing it"));
                 conn = nullptr;
             }
-            // We do not use a sticky connection in case of a nsHttpPipeline as
-            // well (see bug 1337826). This is a quick fix, because
-            // nsHttpPipeline is turned off by default.
-            RefPtr<nsAHttpTransaction> tranConn = do_QueryObject(conn);
-            if (tranConn && tranConn->QueryPipeline()) {
-                LOG(("Do not use this connection, it is a nsHttpPipeline."));
-                conn = nullptr;
-            }
         }
 
         RefPtr<nsAHttpConnection> stickyConn;
         if (mCaps & NS_HTTP_STICKY_CONNECTION) {
             stickyConn = mTransaction->GetConnectionReference();
         }
 
         mTransferSize = mTransaction->GetTransferSize();
@@ -7677,19 +7501,18 @@ nsHttpChannel::DoAuthRetry(nsAHttpConnec
 
     // rewind the upload stream
     if (mUploadStream) {
         nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(mUploadStream);
         if (seekable)
             seekable->Seek(nsISeekableStream::NS_SEEK_SET, 0);
     }
 
-    // set sticky connection flag and disable pipelining.
+    // set sticky connection flag
     mCaps |=  NS_HTTP_STICKY_CONNECTION;
-    mCaps &= ~NS_HTTP_ALLOW_PIPELINING;
 
     // and create a new one...
     rv = SetupTransaction();
     if (NS_FAILED(rv)) return rv;
 
     // transfer ownership of connection to transaction
     if (conn)
         mTransaction->SetConnection(conn);
--- a/netwerk/protocol/http/nsHttpConnection.cpp
+++ b/netwerk/protocol/http/nsHttpConnection.cpp
@@ -17,17 +17,16 @@
 #define TLS_EARLY_DATA_AVAILABLE_BUT_NOT_USED 1
 #define TLS_EARLY_DATA_AVAILABLE_AND_USED 2
 
 #include "ASpdySession.h"
 #include "mozilla/ChaosMode.h"
 #include "mozilla/Telemetry.h"
 #include "nsHttpConnection.h"
 #include "nsHttpHandler.h"
-#include "nsHttpPipeline.h"
 #include "nsHttpRequestHead.h"
 #include "nsHttpResponseHead.h"
 #include "nsIOService.h"
 #include "nsISocketTransport.h"
 #include "nsSocketTransportService2.h"
 #include "nsISSLSocketControl.h"
 #include "nsISupportsPriority.h"
 #include "nsPreloadedStream.h"
@@ -54,29 +53,27 @@ nsHttpConnection::nsHttpConnection()
     , mMaxBytesRead(0)
     , mTotalBytesRead(0)
     , mTotalBytesWritten(0)
     , mContentBytesWritten(0)
     , mConnectedTransport(false)
     , mKeepAlive(true) // assume to keep-alive by default
     , mKeepAliveMask(true)
     , mDontReuse(false)
-    , mSupportsPipelining(false) // assume low-grade server
     , mIsReused(false)
     , mCompletedProxyConnect(false)
     , mLastTransactionExpectedNoContent(false)
     , mIdleMonitoring(false)
     , mProxyConnectInProgress(false)
     , mExperienced(false)
     , mInSpdyTunnel(false)
     , mForcePlainText(false)
     , mTrafficStamp(false)
     , mHttp1xTransactionCount(0)
     , mRemainingConnectionUses(0xffffffff)
-    , mClassification(nsAHttpTransaction::CLASS_GENERAL)
     , mNPNComplete(false)
     , mSetupSSLCalled(false)
     , mUsingSpdyVersion(0)
     , mPriority(nsISupportsPriority::PRIORITY_NORMAL)
     , mReportedSpdy(false)
     , mEverUsedSpdy(false)
     , mLastHttpResponseVersion(NS_HTTP_VERSION_1_1)
     , mTransactionCaps(0)
@@ -136,18 +133,16 @@ nsHttpConnection::Init(nsHttpConnectionI
 {
     LOG(("nsHttpConnection::Init this=%p", this));
     NS_ENSURE_ARG_POINTER(info);
     NS_ENSURE_TRUE(!mConnInfo, NS_ERROR_ALREADY_INITIALIZED);
 
     mConnectedTransport = connectedTransport;
     mConnInfo = info;
     mLastWriteTime = mLastReadTime = PR_IntervalNow();
-    mSupportsPipelining =
-        gHttpHandler->ConnMgr()->SupportsPipelining(mConnInfo);
     mRtt = rtt;
     mMaxHangTime = PR_SecondsToInterval(maxHangTime);
 
     mSocketTransport = transport;
     mSocketIn = instream;
     mSocketOut = outstream;
 
     // See explanation for non-strictness of this operation in SetSecurityCallbacks.
@@ -273,17 +268,17 @@ nsHttpConnection::StartSpdy(uint8_t spdy
     }
 
     // Setting the connection as reused allows some transactions that fail
     // with NS_ERROR_NET_RESET to be restarted and SPDY uses that code
     // to handle clean rejections (such as those that arrived after
     // a server goaway was generated).
     mIsReused = true;
 
-    // If mTransaction is a pipeline object it might represent
+    // If mTransaction is a muxed object it might represent
     // several requests. If so, we need to unpack that and
     // pack them all into a new spdy session.
 
     nsTArray<RefPtr<nsAHttpTransaction> > list;
     nsresult rv = NS_OK;
     if (!mDid0RTTSpdy) {
         rv = TryTakeSubTransactions(list);
 
@@ -320,17 +315,16 @@ nsHttpConnection::StartSpdy(uint8_t spdy
 
     // Disable TCP Keepalives - use SPDY ping instead.
     rv = DisableTCPKeepalives();
     if (NS_FAILED(rv)) {
         LOG(("nsHttpConnection::StartSpdy [%p] DisableTCPKeepalives failed "
              "rv[0x%" PRIx32 "]", this, static_cast<uint32_t>(rv)));
     }
 
-    mSupportsPipelining = false; // don't use http/1 pipelines with spdy
     mIdleTimeout = gHttpHandler->SpdyTimeout();
 
     if (!mTLSFilter) {
         mTransaction = mSpdySession;
     } else {
         mTLSFilter->SetProxiedTransaction(mSpdySession);
     }
     if (mDontReuse) {
@@ -876,48 +870,34 @@ nsHttpConnection::DontReuse()
     mKeepAliveMask = false;
     mKeepAlive = false;
     mDontReuse = true;
     mIdleTimeout = 0;
     if (mSpdySession)
         mSpdySession->DontReuse();
 }
 
-// Checked by the Connection Manager before scheduling a pipelined transaction
-bool
-nsHttpConnection::SupportsPipelining()
-{
-    if (mTransaction &&
-        mTransaction->PipelineDepth() >= mRemainingConnectionUses) {
-        LOG(("nsHttpConnection::SupportsPipelining this=%p deny pipeline "
-             "because current depth %d exceeds max remaining uses %d\n",
-             this, mTransaction->PipelineDepth(), mRemainingConnectionUses));
-        return false;
-    }
-    return mSupportsPipelining && IsKeepAlive() && !mDontReuse;
-}
-
 bool
 nsHttpConnection::CanReuse()
 {
-    if (mDontReuse)
+    if (mDontReuse || !mRemainingConnectionUses) {
         return false;
+    }
 
-    if ((mTransaction ? mTransaction->PipelineDepth() : 0) >=
+    if ((mTransaction ? (mTransaction->IsDone() ? 0U : 1U) : 0U) >=
         mRemainingConnectionUses) {
         return false;
     }
 
     bool canReuse;
-
-    if (mSpdySession)
+    if (mSpdySession) {
         canReuse = mSpdySession->CanReuse();
-    else
+    } else {
         canReuse = IsKeepAlive();
-
+    }
     canReuse = canReuse && (IdleTime() < mIdleTimeout) && IsAlive();
 
     // An idle persistent connection should not have data waiting to be read
     // before a request is sent. Data here is likely a 408 timeout response
     // which we would deal with later on through the restart logic, but that
     // path is more expensive than just closing the socket now.
 
     uint64_t dataSize;
@@ -986,74 +966,16 @@ nsHttpConnection::IsAlive()
         LOG(("pretending socket is still alive to test restart logic\n"));
         alive = true;
     }
 #endif
 
     return alive;
 }
 
-bool
-nsHttpConnection::SupportsPipelining(nsHttpResponseHead *responseHead)
-{
-    // SPDY supports infinite parallelism, so no need to pipeline.
-    if (mUsingSpdyVersion)
-        return false;
-
-    // assuming connection is HTTP/1.1 with keep-alive enabled
-    if (mConnInfo->UsingHttpProxy() && !mConnInfo->UsingConnect()) {
-        // XXX check for bad proxy servers...
-        return true;
-    }
-
-    // check for bad origin servers
-    nsAutoCString val;
-    responseHead->GetHeader(nsHttp::Server, val);
-
-    // If there is no server header we will assume it should not be banned
-    // as facebook and some other prominent sites do this
-    if (val.IsEmpty())
-        return true;
-
-    // The blacklist is indexed by the first character. All of these servers are
-    // known to return their identifier as the first thing in the server string,
-    // so we can do a leading match.
-
-    static const char *bad_servers[26][6] = {
-        { nullptr }, { nullptr }, { nullptr }, { nullptr },                 // a - d
-        { "EFAServer/", nullptr },                                       // e
-        { nullptr }, { nullptr }, { nullptr }, { nullptr },                 // f - i
-        { nullptr }, { nullptr }, { nullptr },                             // j - l
-        { "Microsoft-IIS/4.", "Microsoft-IIS/5.", nullptr },             // m
-        { "Netscape-Enterprise/3.", "Netscape-Enterprise/4.",
-          "Netscape-Enterprise/5.", "Netscape-Enterprise/6.", nullptr }, // n
-        { nullptr }, { nullptr }, { nullptr }, { nullptr },                 // o - r
-        { nullptr }, { nullptr }, { nullptr }, { nullptr },                 // s - v
-        { "WebLogic 3.", "WebLogic 4.","WebLogic 5.", "WebLogic 6.",
-          "Winstone Servlet Engine v0.", nullptr },                      // w
-        { nullptr }, { nullptr }, { nullptr }                              // x - z
-    };
-
-    int index = val.get()[0] - 'A'; // the whole table begins with capital letters
-    if ((index >= 0) && (index <= 25))
-    {
-        for (int i = 0; bad_servers[index][i] != nullptr; i++) {
-            if (val.Equals(bad_servers[index][i])) {
-                LOG(("looks like this server does not support pipelining"));
-                gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-                    mConnInfo, nsHttpConnectionMgr::RedBannedServer, this , 0);
-                return false;
-            }
-        }
-    }
-
-    // ok, let's allow pipelining to this server
-    return true;
-}
-
 //----------------------------------------------------------------------------
 // nsHttpConnection::nsAHttpConnection compatible methods
 //----------------------------------------------------------------------------
 
 nsresult
 nsHttpConnection::OnHeadersAvailable(nsAHttpTransaction *trans,
                                      nsHttpRequestHead *requestHead,
                                      nsHttpResponseHead *responseHead,
@@ -1101,82 +1023,30 @@ nsHttpConnection::OnHeadersAvailable(nsA
 
         // timeouts that are not caused by persistent connection reuse should
         // not be retried for browser compatibility reasons. bug 907800. The
         // server driven close is implicit in the 408.
         explicitClose = true;
         explicitKeepAlive = false;
     }
 
-    // reset to default (the server may have changed since we last checked)
-    mSupportsPipelining = false;
-
     if ((responseHead->Version() < NS_HTTP_VERSION_1_1) ||
         (requestHead->Version() < NS_HTTP_VERSION_1_1)) {
         // HTTP/1.0 connections are by default NOT persistent
         if (explicitKeepAlive)
             mKeepAlive = true;
         else
             mKeepAlive = false;
-
-        // We need at least version 1.1 to use pipelines
-        gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-            mConnInfo, nsHttpConnectionMgr::RedVersionTooLow, this, 0);
     }
     else {
         // HTTP/1.1 connections are by default persistent
-        if (explicitClose) {
-            mKeepAlive = false;
-
-            // persistent connections are required for pipelining to work - if
-            // this close was not pre-announced then generate the negative
-            // BadExplicitClose feedback
-            if (mRemainingConnectionUses > 1)
-                gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-                    mConnInfo, nsHttpConnectionMgr::BadExplicitClose, this, 0);
-        }
-        else {
-            mKeepAlive = true;
-
-            // Do not support pipelining when we are establishing
-            // an SSL tunnel though an HTTP proxy. Pipelining support
-            // determination must be based on comunication with the
-            // target server in this case. See bug 422016 for futher
-            // details.
-            if (!mProxyConnectStream)
-              mSupportsPipelining = SupportsPipelining(responseHead);
-        }
+        mKeepAlive = !explicitClose;
     }
     mKeepAliveMask = mKeepAlive;
 
-    // Update the pipelining status in the connection info object
-    // and also read it back. It is possible the ci status is
-    // locked to false if pipelining has been banned on this ci due to
-    // some kind of observed flaky behavior
-    if (mSupportsPipelining) {
-        // report the pipelining-compatible header to the connection manager
-        // as positive feedback. This will undo 1 penalty point the host
-        // may have accumulated in the past.
-
-        gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-            mConnInfo, nsHttpConnectionMgr::NeutralExpectedOK, this, 0);
-
-        mSupportsPipelining =
-            gHttpHandler->ConnMgr()->SupportsPipelining(mConnInfo);
-    }
-
-    // If this connection is reserved for revalidations and we are
-    // receiving a document that failed revalidation then switch the
-    // classification to general to avoid pipelining more revalidations behind
-    // it.
-    if (mClassification == nsAHttpTransaction::CLASS_REVALIDATION &&
-        responseStatus != 304) {
-        mClassification = nsAHttpTransaction::CLASS_GENERAL;
-    }
-
     // if this connection is persistent, then the server may send a "Keep-Alive"
     // header specifying the maximum number of times the connection can be
     // reused as well as the maximum amount of time the connection can be idle
     // before the server will close it.  we ignore the max reuse count, because
     // a "keep-alive" connection is by definition capable of being reused, and
     // we only care about being able to reuse it once.  if a timeout is not
     // specified then we use our advertized timeout value.
     bool foundKeepAliveMax = false;
@@ -1392,77 +1262,17 @@ nsHttpConnection::ReadTimeoutTick(PRInte
             CloseTransaction(mTransaction, NS_ERROR_NET_TIMEOUT);
             return UINT32_MAX;
         }
         nextTickAfter = PR_IntervalToSeconds(mTransaction->ResponseTimeout()) -
                         PR_IntervalToSeconds(initialResponseDelta);
         nextTickAfter = std::max(nextTickAfter, 1U);
     }
 
-    if (!gHttpHandler->GetPipelineRescheduleOnTimeout())
-        return nextTickAfter;
-
-    PRIntervalTime delta = now - mLastReadTime;
-
-    // we replicate some of the checks both here and in OnSocketReadable() as
-    // they will be discovered under different conditions. The ones here
-    // will generally be discovered if we are totally hung and OSR does
-    // not get called at all, however OSR discovers them with lower latency
-    // if the issue is just very slow (but not stalled) reading.
-    //
-    // Right now we only take action if pipelining is involved, but this would
-    // be the place to add general read timeout handling if it is desired.
-
-    uint32_t pipelineDepth = mTransaction->PipelineDepth();
-    if (pipelineDepth > 1) {
-        // if we have pipelines outstanding (not just an idle connection)
-        // then get a fairly quick tick
-        nextTickAfter = 1;
-    }
-
-    if (delta >= gHttpHandler->GetPipelineRescheduleTimeout() &&
-        pipelineDepth > 1) {
-
-        // this just reschedules blocked transactions. no transaction
-        // is aborted completely.
-        LOG(("cancelling pipeline due to a %ums stall - depth %d\n",
-             PR_IntervalToMilliseconds(delta), pipelineDepth));
-
-        nsHttpPipeline *pipeline = mTransaction->QueryPipeline();
-        MOZ_ASSERT(pipeline, "pipelinedepth > 1 without pipeline");
-        // code this defensively for the moment and check for null in opt build
-        // This will reschedule blocked members of the pipeline, but the
-        // blocking transaction (i.e. response 0) will not be changed.
-        if (pipeline) {
-            pipeline->CancelPipeline(NS_ERROR_NET_TIMEOUT);
-            LOG(("Rescheduling the head of line blocked members of a pipeline "
-                 "because reschedule-timeout idle interval exceeded"));
-        }
-    }
-
-    if (delta < gHttpHandler->GetPipelineTimeout())
-        return nextTickAfter;
-
-    if (pipelineDepth <= 1 && !mTransaction->PipelinePosition())
-        return nextTickAfter;
-
-    // nothing has transpired on this pipelined socket for many
-    // seconds. Call that a total stall and close the transaction.
-    // There is a chance the transaction will be restarted again
-    // depending on its state.. that will come back araound
-    // without pipelining on, so this won't loop.
-
-    LOG(("canceling transaction stalled for %ums on a pipeline "
-         "of depth %d and scheduled originally at pos %d\n",
-         PR_IntervalToMilliseconds(delta),
-         pipelineDepth, mTransaction->PipelinePosition()));
-
-    // This will also close the connection
-    CloseTransaction(mTransaction, NS_ERROR_NET_TIMEOUT);
-    return UINT32_MAX;
+    return nextTickAfter;
 }
 
 void
 nsHttpConnection::UpdateTCPKeepalive(nsITimer *aTimer, void *aClosure)
 {
     MOZ_ASSERT(aTimer);
     MOZ_ASSERT(aClosure);
 
@@ -1942,59 +1752,18 @@ nsHttpConnection::OnSocketReadable()
     if (mKeepAliveMask && (delta >= mMaxHangTime)) {
         LOG(("max hang time exceeded!\n"));
         // give the handler a chance to create a new persistent connection to
         // this host if we've been busy for too long.
         mKeepAliveMask = false;
         gHttpHandler->ProcessPendingQ(mConnInfo);
     }
 
-    // Look for data being sent in bursts with large pauses. If the pauses
-    // are caused by server bottlenecks such as think-time, disk i/o, or
-    // cpu exhaustion (as opposed to network latency) then we generate negative
-    // pipelining feedback to prevent head of line problems
-
     // Reduce the estimate of the time since last read by up to 1 RTT to
     // accommodate exhausted sender TCP congestion windows or minor I/O delays.
-
-    if (delta > mRtt)
-        delta -= mRtt;
-    else
-        delta = 0;
-
-    static const PRIntervalTime k400ms  = PR_MillisecondsToInterval(400);
-
-    if (delta >= (mRtt + gHttpHandler->GetPipelineRescheduleTimeout())) {
-        LOG(("Read delta ms of %u causing slow read major "
-             "event and pipeline cancellation",
-             PR_IntervalToMilliseconds(delta)));
-
-        gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-            mConnInfo, nsHttpConnectionMgr::BadSlowReadMajor, this, 0);
-
-        if (gHttpHandler->GetPipelineRescheduleOnTimeout() &&
-            mTransaction->PipelineDepth() > 1) {
-            nsHttpPipeline *pipeline = mTransaction->QueryPipeline();
-            MOZ_ASSERT(pipeline, "pipelinedepth > 1 without pipeline");
-            // code this defensively for the moment and check for null
-            // This will reschedule blocked members of the pipeline, but the
-            // blocking transaction (i.e. response 0) will not be changed.
-            if (pipeline) {
-                pipeline->CancelPipeline(NS_ERROR_NET_TIMEOUT);
-                LOG(("Rescheduling the head of line blocked members of a "
-                     "pipeline because reschedule-timeout idle interval "
-                     "exceeded"));
-            }
-        }
-    }
-    else if (delta > k400ms) {
-        gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-            mConnInfo, nsHttpConnectionMgr::BadSlowReadMinor, this, 0);
-    }
-
     mLastReadTime = now;
 
     nsresult rv;
     uint32_t n;
     bool again = true;
 
     do {
         if (!mProxyConnectInProgress && !mNPNComplete) {
--- a/netwerk/protocol/http/nsHttpConnection.h
+++ b/netwerk/protocol/http/nsHttpConnection.h
@@ -77,17 +77,16 @@ public:
     nsresult Activate(nsAHttpTransaction *, uint32_t caps, int32_t pri);
 
     // Close the underlying socket transport.
     void Close(nsresult reason, bool aIsShutdown = false);
 
     //-------------------------------------------------------------------------
     // 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();
 
     // Returns time in seconds for how long connection can be reused.
@@ -172,22 +171,16 @@ public:
     // other connections.
     uint32_t  ReadTimeoutTick(PRIntervalTime now);
 
     // For Active and Idle connections, this will be called when
     // mTCPKeepaliveTransitionTimer fires, to check if the TCP keepalive config
     // should move from short-lived (fast-detect) to long-lived.
     static void UpdateTCPKeepalive(nsITimer *aTimer, void *aClosure);
 
-    nsAHttpTransaction::Classifier Classification() { return mClassification; }
-    void Classify(nsAHttpTransaction::Classifier newclass)
-    {
-        mClassification = newclass;
-    }
-
     // When the connection is active this is called every second
     void  ReadTimeoutTick();
 
     int64_t BytesWritten() { return mTotalBytesWritten; } // includes TLS
     int64_t ContentBytesWritten() { return mContentBytesWritten; }
 
     void    SetSecurityCallbacks(nsIInterfaceRequestor* aCallbacks);
     void    PrintDiagnostics(nsCString &log);
@@ -233,17 +226,16 @@ private:
     nsresult OnTransactionDone(nsresult reason);
     nsresult OnSocketWritable();
     nsresult OnSocketReadable();
 
     nsresult SetupProxyConnect();
 
     PRIntervalTime IdleTime();
     bool     IsAlive();
-    bool     SupportsPipelining(nsHttpResponseHead *);
 
     // Makes certain the SSL handshake is complete and NPN negotiation
     // has had a chance to happen
     bool     EnsureNPNComplete(nsresult &aOut0RTTWriteHandshakeValue,
                                uint32_t &aOut0RTTBytesWritten);
     void     SetupSSL();
 
     // Start the Spdy transaction handler when NPN indicates spdy/*
@@ -303,17 +295,16 @@ private:
     RefPtr<nsIAsyncInputStream>   mInputOverflow;
 
     PRIntervalTime                  mRtt;
 
     bool                            mConnectedTransport;
     bool                            mKeepAlive;
     bool                            mKeepAliveMask;
     bool                            mDontReuse;
-    bool                            mSupportsPipelining;
     bool                            mIsReused;
     bool                            mCompletedProxyConnect;
     bool                            mLastTransactionExpectedNoContent;
     bool                            mIdleMonitoring;
     bool                            mProxyConnectInProgress;
     bool                            mExperienced;
     bool                            mInSpdyTunnel;
     bool                            mForcePlainText;
@@ -326,18 +317,16 @@ private:
     // excludes spdy transactions.
     uint32_t                        mHttp1xTransactionCount;
 
     // Keep-Alive: max="mRemainingConnectionUses" provides the number of future
     // transactions (including the current one) that the server expects to allow
     // on this persistent connection.
     uint32_t                        mRemainingConnectionUses;
 
-    nsAHttpTransaction::Classifier  mClassification;
-
     // SPDY related
     bool                            mNPNComplete;
     bool                            mSetupSSLCalled;
 
     // version level in use, 0 if unused
     uint8_t                         mUsingSpdyVersion;
 
     RefPtr<ASpdySession>            mSpdySession;
--- a/netwerk/protocol/http/nsHttpConnectionMgr.cpp
+++ b/netwerk/protocol/http/nsHttpConnectionMgr.cpp
@@ -9,17 +9,16 @@
 // Log on level :5, instead of default :4.
 #undef LOG
 #define LOG(args) LOG5(args)
 #undef LOG_ENABLED
 #define LOG_ENABLED() LOG5_ENABLED()
 
 #include "nsHttpConnectionMgr.h"
 #include "nsHttpConnection.h"
-#include "nsHttpPipeline.h"
 #include "nsHttpHandler.h"
 #include "nsIHttpChannelInternal.h"
 #include "nsNetCID.h"
 #include "nsCOMPtr.h"
 #include "nsNetUtil.h"
 #include "mozilla/net/DNS.h"
 #include "nsISocketTransport.h"
 #include "nsISSLSocketControl.h"
@@ -118,31 +117,27 @@ nsHttpConnectionMgr::EnsureSocketThreadT
 
     return rv;
 }
 
 nsresult
 nsHttpConnectionMgr::Init(uint16_t maxConns,
                           uint16_t maxPersistConnsPerHost,
                           uint16_t maxPersistConnsPerProxy,
-                          uint16_t maxRequestDelay,
-                          uint16_t maxPipelinedRequests,
-                          uint16_t maxOptimisticPipelinedRequests)
+                          uint16_t maxRequestDelay)
 {
     LOG(("nsHttpConnectionMgr::Init\n"));
 
     {
         ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 
         mMaxConns = maxConns;
         mMaxPersistConnsPerHost = maxPersistConnsPerHost;
         mMaxPersistConnsPerProxy = maxPersistConnsPerProxy;
         mMaxRequestDelay = maxRequestDelay;
-        mMaxPipelinedRequests = maxPipelinedRequests;
-        mMaxOptimisticPipelinedRequests = maxOptimisticPipelinedRequests;
 
         mIsShuttingDown = false;
     }
 
     return EnsureSocketThreadTarget();
 }
 
 class BoolWrapper : public ARefBase
@@ -933,123 +928,16 @@ nsHttpConnectionMgr::ProcessPendingQForE
     MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
 
     nsConnectionEntry *ent = mCT.Get(ci->HashKey());
     if (ent)
         return ProcessPendingQForEntry(ent, false);
     return false;
 }
 
-bool
-nsHttpConnectionMgr::SupportsPipelining(nsHttpConnectionInfo *ci)
-{
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-
-    nsConnectionEntry *ent = mCT.Get(ci->HashKey());
-    if (ent)
-        return ent->SupportsPipelining();
-    return false;
-}
-
-// nsHttpPipelineFeedback used to hold references across events
-
-class nsHttpPipelineFeedback : public ARefBase
-{
-public:
-    nsHttpPipelineFeedback(nsHttpConnectionInfo *ci,
-                           nsHttpConnectionMgr::PipelineFeedbackInfoType info,
-                           nsHttpConnection *conn, uint32_t data)
-        : mConnInfo(ci)
-        , mConn(conn)
-        , mInfo(info)
-        , mData(data)
-        {
-        }
-
-
-    RefPtr<nsHttpConnectionInfo> mConnInfo;
-    RefPtr<nsHttpConnection> mConn;
-    nsHttpConnectionMgr::PipelineFeedbackInfoType mInfo;
-    uint32_t mData;
-private:
-    ~nsHttpPipelineFeedback() {}
-    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsHttpPipelineFeedback)
-};
-
-void
-nsHttpConnectionMgr::PipelineFeedbackInfo(nsHttpConnectionInfo *ci,
-                                          PipelineFeedbackInfoType info,
-                                          nsHttpConnection *conn,
-                                          uint32_t data)
-{
-    if (!ci)
-        return;
-
-    // Post this to the socket thread if we are not running there already
-    if (PR_GetCurrentThread() != gSocketThread) {
-        RefPtr<nsHttpPipelineFeedback> fb =
-            new nsHttpPipelineFeedback(ci, info, conn, data);
-        PostEvent(&nsHttpConnectionMgr::OnMsgProcessFeedback, 0, fb);
-        return;
-    }
-
-    nsConnectionEntry *ent = mCT.Get(ci->HashKey());
-    if (ent)
-        ent->OnPipelineFeedbackInfo(info, conn, data);
-}
-
-void
-nsHttpConnectionMgr::ReportFailedToProcess(nsIURI *uri)
-{
-    MOZ_ASSERT(uri);
-
-    nsAutoCString host;
-    int32_t port = -1;
-    nsAutoCString username;
-    bool usingSSL = false;
-    bool isHttp = false;
-
-    nsresult rv = uri->SchemeIs("https", &usingSSL);
-    if (NS_SUCCEEDED(rv) && usingSSL)
-        isHttp = true;
-    if (NS_SUCCEEDED(rv) && !isHttp)
-        rv = uri->SchemeIs("http", &isHttp);
-    if (NS_SUCCEEDED(rv))
-        rv = uri->GetAsciiHost(host);
-    if (NS_SUCCEEDED(rv))
-        rv = uri->GetPort(&port);
-    if (NS_SUCCEEDED(rv))
-        uri->GetUsername(username);
-    if (NS_FAILED(rv) || !isHttp || host.IsEmpty())
-        return;
-
-    // report the event for all the permutations of anonymous and
-    // private versions of this host
-    RefPtr<nsHttpConnectionInfo> ci =
-        new nsHttpConnectionInfo(host, port, EmptyCString(), username, nullptr,
-                                 OriginAttributes(), usingSSL);
-    ci->SetAnonymous(false);
-    ci->SetPrivate(false);
-    PipelineFeedbackInfo(ci, RedCorruptedContent, nullptr, 0);
-
-    ci = ci->Clone();
-    ci->SetAnonymous(false);
-    ci->SetPrivate(true);
-    PipelineFeedbackInfo(ci, RedCorruptedContent, nullptr, 0);
-
-    ci = ci->Clone();
-    ci->SetAnonymous(true);
-    ci->SetPrivate(false);
-    PipelineFeedbackInfo(ci, RedCorruptedContent, nullptr, 0);
-
-    ci = ci->Clone();
-    ci->SetAnonymous(true);
-    ci->SetPrivate(true);
-    PipelineFeedbackInfo(ci, RedCorruptedContent, nullptr, 0);
-}
 
 // we're at the active connection limit if any one of the following conditions is true:
 //  (1) at max-connections
 //  (2) keep-alive enabled and at max-persistent-connections-per-server/proxy
 //  (3) keep-alive disabled and at max-connections-per-server
 bool
 nsHttpConnectionMgr::AtActiveConnectionLimit(nsConnectionEntry *ent, uint32_t caps)
 {
@@ -1302,150 +1190,16 @@ nsHttpConnectionMgr::MakeNewConnection(n
         if (rv == NS_ERROR_NOT_AVAILABLE)
             rv = NS_ERROR_FAILURE;
         return rv;
     }
 
     return NS_OK;
 }
 
-bool
-nsHttpConnectionMgr::AddToShortestPipeline(nsConnectionEntry *ent,
-                                           nsHttpTransaction *trans,
-                                           nsHttpTransaction::Classifier classification,
-                                           uint16_t depthLimit)
-{
-    if (classification == nsAHttpTransaction::CLASS_SOLO)
-        return false;
-
-    uint32_t maxdepth = ent->MaxPipelineDepth(classification);
-    if (maxdepth == 0) {
-        ent->CreditPenalty();
-        maxdepth = ent->MaxPipelineDepth(classification);
-    }
-
-    if (ent->PipelineState() == PS_RED)
-        return false;
-
-    if (ent->PipelineState() == PS_YELLOW && ent->mYellowConnection)
-        return false;
-
-    // The maximum depth of a pipeline in yellow is 1 pipeline of
-    // depth 2 for entire CI. When that transaction completes successfully
-    // we transition to green and that expands the allowed depth
-    // to any number of pipelines of up to depth 4.  When a transaction
-    // queued at position 3 or deeper succeeds we open it all the way
-    // up to depths limited only by configuration. The staggered start
-    // in green is simply because a successful yellow test of depth=2
-    // might really just be a race condition (i.e. depth=1 from the
-    // server's point of view), while depth=3 is a stronger indicator -
-    // keeping the pipelines to a modest depth during that period limits
-    // the damage if something is going to go wrong.
-
-    maxdepth = std::min<uint32_t>(maxdepth, depthLimit);
-
-    if (maxdepth < 2)
-        return false;
-
-    nsAHttpTransaction *activeTrans;
-
-    nsHttpConnection *bestConn = nullptr;
-    uint32_t activeCount = ent->mActiveConns.Length();
-    uint32_t bestConnLength = 0;
-    uint32_t connLength;
-
-    for (uint32_t i = 0; i < activeCount; ++i) {
-        nsHttpConnection *conn = ent->mActiveConns[i];
-        if (!conn->SupportsPipelining())
-            continue;
-
-        if (conn->Classification() != classification)
-            continue;
-
-        activeTrans = conn->Transaction();
-        if (!activeTrans ||
-            activeTrans->IsDone() ||
-            NS_FAILED(activeTrans->Status()))
-            continue;
-
-        connLength = activeTrans->PipelineDepth();
-
-        if (maxdepth <= connLength)
-            continue;
-
-        if (!bestConn || (connLength < bestConnLength)) {
-            bestConn = conn;
-            bestConnLength = connLength;
-        }
-    }
-
-    if (!bestConn)
-        return false;
-
-    activeTrans = bestConn->Transaction();
-    nsresult rv = activeTrans->AddTransaction(trans);
-    if (NS_FAILED(rv))
-        return false;
-
-    LOG(("   scheduling trans %p on pipeline at position %d\n",
-         trans, trans->PipelinePosition()));
-
-    if ((ent->PipelineState() == PS_YELLOW) && (trans->PipelinePosition() > 1))
-        ent->SetYellowConnection(bestConn);
-
-    if (!trans->GetPendingTime().IsNull()) {
-        if (trans->UsesPipelining())
-            AccumulateTimeDelta(
-                Telemetry::TRANSACTION_WAIT_TIME_HTTP_PIPELINES,
-                trans->GetPendingTime(), TimeStamp::Now());
-        else
-            AccumulateTimeDelta(
-                Telemetry::TRANSACTION_WAIT_TIME_HTTP,
-                trans->GetPendingTime(), TimeStamp::Now());
-        trans->SetPendingTime(false);
-    }
-    return true;
-}
-
-bool
-nsHttpConnectionMgr::IsUnderPressure(nsConnectionEntry *ent,
-                                   nsHttpTransaction::Classifier classification)
-{
-    // A connection entry is declared to be "under pressure" if most of the
-    // allowed parallel connections are already used up. In that case we want to
-    // favor existing pipelines over more parallelism so as to reserve any
-    // unused parallel connections for types that don't have existing pipelines.
-    //
-    // The definition of connection pressure is a pretty liberal one here - that
-    // is why we are using the more restrictive maxPersist* counters.
-    //
-    // Pipelines are also favored when the requested classification is already
-    // using 3 or more of the connections. Failure to do this could result in
-    // one class (e.g. images) establishing self replenishing queues on all the
-    // connections that would starve the other transaction types.
-
-    int32_t currentConns = ent->mActiveConns.Length();
-    int32_t maxConns =
-        (ent->mConnInfo->UsingHttpProxy() && !ent->mConnInfo->UsingConnect()) ?
-        mMaxPersistConnsPerProxy : mMaxPersistConnsPerHost;
-
-    // Leave room for at least 3 distinct types to operate concurrently,
-    // this satisfies the typical {html, js/css, img} page.
-    if (currentConns >= (maxConns - 2))
-        return true;                           /* prefer pipeline */
-
-    int32_t sameClass = 0;
-    for (int32_t i = 0; i < currentConns; ++i)
-        if (classification == ent->mActiveConns[i]->Classification())
-            if (++sameClass == 3)
-                return true;                   /* prefer pipeline */
-
-    return false;                              /* normal behavior */
-}
-
 // returns OK if a connection is found for the transaction
 //   and the transaction is started.
 // returns ERROR_NOT_AVAILABLE if no connection can be found and it
 //   should be queued until circumstances change
 // returns other ERROR when transaction has a hard failure and should
 //   not remain in the pending queue
 nsresult
 nsHttpConnectionMgr::TryDispatchTransaction(nsConnectionEntry *ent,
@@ -1456,38 +1210,32 @@ nsHttpConnectionMgr::TryDispatchTransact
     LOG(("nsHttpConnectionMgr::TryDispatchTransaction without conn "
          "[trans=%p ci=%p ci=%s caps=%x tunnelprovider=%p onlyreused=%d "
          "active=%" PRIuSIZE " idle=%" PRIuSIZE "]\n", trans,
          ent->mConnInfo.get(), ent->mConnInfo->HashKey().get(),
          uint32_t(trans->Caps()), trans->TunnelProvider(),
          onlyReusedConnection, ent->mActiveConns.Length(),
          ent->mIdleConns.Length()));
 
-    nsHttpTransaction::Classifier classification = trans->Classification();
     uint32_t caps = trans->Caps();
 
-    // no keep-alive means no pipelines either
-    if (!(caps & NS_HTTP_ALLOW_KEEPALIVE))
-        caps = caps & ~NS_HTTP_ALLOW_PIPELINING;
-
     // 0 - If this should use spdy then dispatch it post haste.
     // 1 - If there is connection pressure then see if we can pipeline this on
     //     a connection of a matching type instead of using a new conn
     // 2 - If there is an idle connection, use it!
     // 3 - if class == reval or script and there is an open conn of that type
     //     then pipeline onto shortest pipeline of that class if limits allow
     // 4 - If we aren't up against our connection limit,
     //     then open a new one
     // 5 - Try a pipeline if we haven't already - this will be unusual because
     //     it implies a low connection pressure situation where
     //     MakeNewConnection() failed.. that is possible, but unlikely, due to
     //     global limits
     // 6 - no connection is available - queue it
 
-    bool attemptedOptimisticPipeline = !(caps & NS_HTTP_ALLOW_PIPELINING);
     RefPtr<nsHttpConnection> unusedSpdyPersistentConnection;
 
     // step 0
     // look for existing spdy connection - that's always best because it is
     // essentially pipelining without head of line blocking
 
     if (!(caps & NS_HTTP_DISALLOW_SPDY) && gHttpHandler->IsSpdyEnabled()) {
         RefPtr<nsHttpConnection> conn = GetSpdyPreferredConn(ent);
@@ -1523,25 +1271,17 @@ nsHttpConnectionMgr::TryDispatchTransact
     } else {
         // Mark the transaction and its load group as blocking right now to prevent
         // other transactions from being reordered in the queue due to slow syns.
         trans->DispatchedAsBlocking();
     }
 
     // step 1
     // If connection pressure, then we want to favor pipelining of any kind
-    if (IsUnderPressure(ent, classification) && !attemptedOptimisticPipeline) {
-        attemptedOptimisticPipeline = true;
-        if (AddToShortestPipeline(ent, trans,
-                                  classification,
-                                  mMaxOptimisticPipelinedRequests)) {
-            LOG(("   dispatched step 1 trans=%p\n", trans));
-            return NS_OK;
-        }
-    }
+    // h1 pipelining has been removed
 
     // Subject most transactions at high parallelism to rate pacing.
     // It will only be actually submitted to the
     // token bucket once, and if possible it is granted admission synchronously.
     // It is important to leave a transaction in the pending queue when blocked by
     // pacing so it can be found on cancel if necessary.
     // Transactions that cause blocking or bypass it (e.g. js/css) are not rate
     // limited.
@@ -1595,28 +1335,17 @@ nsHttpConnectionMgr::TryDispatchTransact
             DispatchTransaction(ent, trans, conn);
             LOG(("   dispatched step 2 (idle) trans=%p\n", trans));
             return NS_OK;
         }
     }
 
     // step 3
     // consider pipelining scripts and revalidations
-    if (!attemptedOptimisticPipeline &&
-        (classification == nsHttpTransaction::CLASS_REVALIDATION ||
-         classification == nsHttpTransaction::CLASS_SCRIPT)) {
-        // Assignation kept here for documentation purpose; Never read after
-        attemptedOptimisticPipeline = true;
-        if (AddToShortestPipeline(ent, trans,
-                                  classification,
-                                  mMaxOptimisticPipelinedRequests)) {
-            LOG(("   dispatched step 3 (pipeline) trans=%p\n", trans));
-            return NS_OK;
-        }
-    }
+    // h1 pipelining has been removed
 
     // step 4
     if (!onlyReusedConnection) {
         nsresult rv = MakeNewConnection(ent, trans);
         if (NS_SUCCEEDED(rv)) {
             // this function returns NOT_AVAILABLE for asynchronous connects
             LOG(("   dispatched step 4 (async new conn) trans=%p\n", trans));
             return NS_ERROR_NOT_AVAILABLE;
@@ -1631,24 +1360,17 @@ nsHttpConnectionMgr::TryDispatchTransact
         }
     } else if (trans->TunnelProvider() && trans->TunnelProvider()->MaybeReTunnel(trans)) {
         LOG(("   sort of dispatched step 4a tunnel requeue trans=%p\n", trans));
         // the tunnel provider took responsibility for making a new tunnel
         return NS_OK;
     }
 
     // step 5
-    if (caps & NS_HTTP_ALLOW_PIPELINING) {
-        if (AddToShortestPipeline(ent, trans,
-                                  classification,
-                                  mMaxPipelinedRequests)) {
-            LOG(("   dispatched step 5 trans=%p\n", trans));
-            return NS_OK;
-        }
-    }
+    // previously pipelined anything here if allowed but h1 pipelining has been removed
 
     // step 6
     if (unusedSpdyPersistentConnection) {
         // to avoid deadlocks, we need to throw away this perfectly valid SPDY
         // connection to make room for a new one that can service a no KEEPALIVE
         // request
         unusedSpdyPersistentConnection->DontReuse();
     }
@@ -1667,17 +1389,17 @@ nsHttpConnectionMgr::DispatchTransaction
     nsresult rv;
 
     LOG(("nsHttpConnectionMgr::DispatchTransaction "
          "[ent-ci=%s %p trans=%p caps=%x conn=%p priority=%d]\n",
          ent->mConnInfo->HashKey().get(), ent, 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.
+    // when a muxed connection (e.g. h2) becomes available.
     trans->CancelPacing(NS_OK);
 
     if (conn->UsingSpdy()) {
         LOG(("Spdy Dispatch Transaction via Activate(). Transaction host = %s, "
              "Connection host = %s\n",
              trans->ConnectionInfo()->Origin(),
              conn->ConnectionInfo()->Origin()));
         rv = conn->Activate(trans, caps, priority);
@@ -1688,41 +1410,32 @@ nsHttpConnectionMgr::DispatchTransaction
             trans->SetPendingTime(false);
         }
         return rv;
     }
 
     MOZ_ASSERT(conn && !conn->Transaction(),
                "DispatchTranaction() on non spdy active connection");
 
-    if (!(caps & NS_HTTP_ALLOW_PIPELINING))
-        conn->Classify(nsAHttpTransaction::CLASS_SOLO);
-    else
-        conn->Classify(trans->Classification());
-
     rv = DispatchAbstractTransaction(ent, trans, caps, conn, priority);
 
     if (NS_SUCCEEDED(rv) && !trans->GetPendingTime().IsNull()) {
-        if (trans->UsesPipelining())
-            AccumulateTimeDelta(Telemetry::TRANSACTION_WAIT_TIME_HTTP_PIPELINES,
-                trans->GetPendingTime(), TimeStamp::Now());
-        else
-            AccumulateTimeDelta(Telemetry::TRANSACTION_WAIT_TIME_HTTP,
-                trans->GetPendingTime(), TimeStamp::Now());
+        AccumulateTimeDelta(Telemetry::TRANSACTION_WAIT_TIME_HTTP,
+                            trans->GetPendingTime(), TimeStamp::Now());
         trans->SetPendingTime(false);
     }
     return rv;
 }
 
 //-----------------------------------------------------------------------------
 // ConnectionHandle
 //
 // thin wrapper around a real connection, used to keep track of references
 // to the connection to determine when the connection may be reused.  the
-// transaction (or pipeline) owns a reference to this handle.  this extra
+// transaction owns a reference to this handle.  this extra
 // layer of indirection greatly simplifies consumer code, avoiding the
 // need for consumer code to know when to give the connection back to the
 // connection manager.
 //
 class ConnectionHandle : public nsAHttpConnection
 {
 public:
     NS_DECL_THREADSAFE_ISUPPORTS
@@ -1756,90 +1469,45 @@ NS_IMPL_ISUPPORTS0(ConnectionHandle)
 // concrete nsHttpTransaction
 nsresult
 nsHttpConnectionMgr::DispatchAbstractTransaction(nsConnectionEntry *ent,
                                                  nsAHttpTransaction *aTrans,
                                                  uint32_t caps,
                                                  nsHttpConnection *conn,
                                                  int32_t priority)
 {
+    nsresult rv;
     MOZ_ASSERT(!conn->UsingSpdy(),
                "Spdy Must Not Use DispatchAbstractTransaction");
     LOG(("nsHttpConnectionMgr::DispatchAbstractTransaction "
          "[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 */
-
-    RefPtr<nsAHttpTransaction> transaction;
-    nsresult rv;
-    if (conn->Classification() != nsAHttpTransaction::CLASS_SOLO) {
-        LOG(("   using pipeline datastructure.\n"));
-        RefPtr<nsHttpPipeline> pipeline;
-        rv = BuildPipeline(ent, aTrans, getter_AddRefs(pipeline));
-        if (!NS_SUCCEEDED(rv))
-            return rv;
-        transaction = pipeline;
-    }
-    else {
-        LOG(("   not using pipeline datastructure due to class solo.\n"));
-        transaction = aTrans;
-    }
-
+    RefPtr<nsAHttpTransaction> transaction(aTrans);
     RefPtr<ConnectionHandle> handle = new ConnectionHandle(conn);
 
     // give the transaction the indirect reference to the connection.
     transaction->SetConnection(handle);
 
     rv = conn->Activate(transaction, caps, priority);
     if (NS_FAILED(rv)) {
       LOG(("  conn->Activate failed [rv=%" PRIx32 "]\n", static_cast<uint32_t>(rv)));
         ent->mActiveConns.RemoveElement(conn);
-        if (conn == ent->mYellowConnection)
-            ent->OnYellowComplete();
         DecrementActiveConnCount(conn);
         ConditionallyStopTimeoutTick();
 
         // sever back references to connection, and do so without triggering
         // a call to ReclaimConnection ;-)
         transaction->SetConnection(nullptr);
         handle->Reset(); // destroy the connection
     }
 
-    // As transaction goes out of scope it will drop the last refernece to the
-    // pipeline if activation failed, in which case this will destroy
-    // the pipeline, which will cause each the transactions owned by the
-    // pipeline to be restarted.
-
     return rv;
 }
 
-nsresult
-nsHttpConnectionMgr::BuildPipeline(nsConnectionEntry *ent,
-                                   nsAHttpTransaction *firstTrans,
-                                   nsHttpPipeline **result)
-{
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-
-    /* form a pipeline here even if nothing is pending so that we
-       can stream-feed it as new transactions arrive */
-
-    /* the first transaction can go in unconditionally - 1 transaction
-       on a nsHttpPipeline object is not a real HTTP pipeline */
-
-    RefPtr<nsHttpPipeline> pipeline = new nsHttpPipeline();
-    pipeline->AddTransaction(firstTrans);
-    pipeline.forget(result);
-    return NS_OK;
-}
-
 void
 nsHttpConnectionMgr::ReportProxyTelemetry(nsConnectionEntry *ent)
 {
     enum { PROXY_NONE = 1, PROXY_HTTP = 2, PROXY_SOCKS = 3, PROXY_HTTPS = 4 };
 
     if (!ent->mConnInfo->UsingProxy())
         Telemetry::Accumulate(Telemetry::HTTP_PROXY_TYPE, PROXY_NONE);
     else if (ent->mConnInfo->UsingHttpsProxy())
@@ -2438,21 +2106,19 @@ nsHttpConnectionMgr::OnMsgPruneDeadConne
                 // happen after timeToNextExpire.
                 if (!mTimer || timeOfNextExpire < mTimeOfNextWakeUp) {
                     PruneDeadConnectionsAfter(timeToNextExpire);
                 }
             } else {
                 ConditionallyStopPruneDeadConnectionsTimer();
             }
 
-            // If this entry is empty, we have too many entries, and this
-            // doesn't represent some painfully determined red condition, then
-            // we can clean it up and restart from yellow.
-            if (ent->PipelineState()       != PS_RED &&
-                mCT.Count()                >  125 &&
+            // If this entry is empty, we have too many entries busy then
+            // we can clean it up and restart
+            if (mCT.Count()                >  125 &&
                 ent->mIdleConns.Length()   == 0 &&
                 ent->mActiveConns.Length() == 0 &&
                 ent->mHalfOpens.Length()   == 0 &&
                 ent->mPendingQ.Length()    == 0 &&
                 (!ent->mUsingSpdy || mCT.Count() > 300)) {
                 LOG(("    removing empty connection entry\n"));
                 iter.Remove();
                 continue;
@@ -2606,19 +2272,16 @@ nsHttpConnectionMgr::OnMsgReclaimConnect
     // a connection that still holds a reference to a transaction was
     // not closed naturally (i.e. it was reset or aborted) and is
     // therefore not something that should be reused.
     if (conn->Transaction()) {
         conn->DontReuse();
     }
 
     if (ent->mActiveConns.RemoveElement(conn)) {
-        if (conn == ent->mYellowConnection) {
-            ent->OnYellowComplete();
-        }
         DecrementActiveConnCount(conn);
         ConditionallyStopTimeoutTick();
     }
 
     if (conn->CanReuse()) {
         LOG(("  adding connection to idle list\n"));
         // Keep The idle connection list sorted with the connections that
         // have moved the largest data pipelines at the front because these
@@ -2691,42 +2354,28 @@ nsHttpConnectionMgr::OnMsgUpdateParam(in
         mMaxPersistConnsPerHost = value;
         break;
     case MAX_PERSISTENT_CONNECTIONS_PER_PROXY:
         mMaxPersistConnsPerProxy = value;
         break;
     case MAX_REQUEST_DELAY:
         mMaxRequestDelay = value;
         break;
-    case MAX_PIPELINED_REQUESTS:
-        mMaxPipelinedRequests = value;
-        break;
-    case MAX_OPTIMISTIC_PIPELINED_REQUESTS:
-        mMaxOptimisticPipelinedRequests = value;
-        break;
     default:
         NS_NOTREACHED("unexpected parameter name");
     }
 }
 
 // nsHttpConnectionMgr::nsConnectionEntry
 nsHttpConnectionMgr::nsConnectionEntry::~nsConnectionEntry()
 {
     MOZ_COUNT_DTOR(nsConnectionEntry);
     gHttpHandler->ConnMgr()->RemovePreferredHash(this);
 }
 
-void
-nsHttpConnectionMgr::OnMsgProcessFeedback(int32_t, ARefBase *param)
-{
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-    nsHttpPipelineFeedback *fb = static_cast<nsHttpPipelineFeedback *>(param);
-    PipelineFeedbackInfo(fb->mConnInfo, fb->mInfo, fb->mConn, fb->mData);
-}
-
 // Read Timeout Tick handlers
 
 void
 nsHttpConnectionMgr::ActivateTimeoutTick()
 {
     MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
     LOG(("nsHttpConnectionMgr::ActivateTimeoutTick() "
          "this=%p mTimeoutTick=%p\n", this, mTimeoutTick.get()));
@@ -3405,22 +3054,20 @@ nsHalfOpenSocket::OnOutputStreamReady(ns
             RefPtr<nsAHttpTransaction> trans;
             if (mTransaction->IsNullTransaction() && !mDispatchedMTransaction) {
                 // null transactions cannot be put in the entry queue, so that
                 // explains why it is not present.
                 mDispatchedMTransaction = true;
                 trans = mTransaction;
             } else {
                 trans = new NullHttpTransaction(mEnt->mConnInfo,
-                                                callbacks,
-                                                mCaps & ~NS_HTTP_ALLOW_PIPELINING);
+                                                callbacks, mCaps);
             }
 
             gHttpHandler->ConnMgr()->AddActiveConn(conn, mEnt);
-            conn->Classify(nsAHttpTransaction::CLASS_SOLO);
             rv = gHttpHandler->ConnMgr()->
                 DispatchAbstractTransaction(mEnt, trans, mCaps, conn, 0);
         } else {
             // otherwise just put this in the persistent connection pool
             LOG(("nsHalfOpenSocket::OnOutputStreamReady no transaction match "
                  "returning conn %p to pool\n", conn.get()));
             gHttpHandler->ConnMgr()->OnMsgReclaimConnection(0, conn);
         }
@@ -3540,304 +3187,43 @@ already_AddRefed<nsHttpConnection>
 ConnectionHandle::TakeHttpConnection()
 {
     // return our connection object to the caller and clear it internally
     // do not drop our reference - the caller now owns it.
     MOZ_ASSERT(mConn);
     return mConn.forget();
 }
 
-uint32_t
-ConnectionHandle::CancelPipeline(nsresult reason)
-{
-    // no pipeline to cancel
-    return 0;
-}
-
-nsAHttpTransaction::Classifier
-ConnectionHandle::Classification()
-{
-    if (mConn)
-        return mConn->Classification();
-
-    LOG(("ConnectionHandle::Classification this=%p "
-         "has null mConn using CLASS_SOLO default", this));
-    return nsAHttpTransaction::CLASS_SOLO;
-}
 
 // nsConnectionEntry
 
 nsHttpConnectionMgr::
 nsConnectionEntry::nsConnectionEntry(nsHttpConnectionInfo *ci)
     : mConnInfo(ci)
-    , mPipelineState(PS_YELLOW)
-    , mYellowGoodEvents(0)
-    , mYellowBadEvents(0)
-    , mYellowConnection(nullptr)
-    , mGreenDepth(kPipelineOpen)
-    , mPipeliningPenalty(0)
     , mUsingSpdy(false)
     , mInPreferredHash(false)
     , mPreferIPv4(false)
     , mPreferIPv6(false)
     , mUsedForConnection(false)
 {
     MOZ_COUNT_CTOR(nsConnectionEntry);
-    if (gHttpHandler->GetPipelineAggressive()) {
-        mGreenDepth = kPipelineUnlimited;
-        mPipelineState = PS_GREEN;
-    }
-    mInitialGreenDepth = mGreenDepth;
-    memset(mPipeliningClassPenalty, 0, sizeof(int16_t) * nsAHttpTransaction::CLASS_MAX);
 }
 
 bool
 nsHttpConnectionMgr::nsConnectionEntry::AvailableForDispatchNow()
 {
     if (mIdleConns.Length() && mIdleConns[0]->CanReuse()) {
         return true;
     }
 
     return gHttpHandler->ConnMgr()->
         GetSpdyPreferredConn(this) ? true : false;
 }
 
 bool
-nsHttpConnectionMgr::nsConnectionEntry::SupportsPipelining()
-{
-    return mPipelineState != nsHttpConnectionMgr::PS_RED;
-}
-
-nsHttpConnectionMgr::PipeliningState
-nsHttpConnectionMgr::nsConnectionEntry::PipelineState()
-{
-    return mPipelineState;
-}
-
-void
-nsHttpConnectionMgr::
-nsConnectionEntry::OnPipelineFeedbackInfo(
-    nsHttpConnectionMgr::PipelineFeedbackInfoType info,
-    nsHttpConnection *conn,
-    uint32_t data)
-{
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-
-    if (mPipelineState == PS_YELLOW) {
-        if (info & kPipelineInfoTypeBad)
-            mYellowBadEvents++;
-        else if (info & (kPipelineInfoTypeNeutral | kPipelineInfoTypeGood))
-            mYellowGoodEvents++;
-    }
-
-    if (mPipelineState == PS_GREEN && info == GoodCompletedOK) {
-        int32_t depth = data;
-        LOG(("Transaction completed at pipeline depth of %d. Host = %s\n",
-             depth, mConnInfo->Origin()));
-
-        if (depth >= 3)
-            mGreenDepth = kPipelineUnlimited;
-    }
-
-    nsAHttpTransaction::Classifier classification;
-    if (conn)
-        classification = conn->Classification();
-    else if (info == BadInsufficientFraming ||
-             info == BadUnexpectedLarge)
-        classification = (nsAHttpTransaction::Classifier) data;
-    else
-        classification = nsAHttpTransaction::CLASS_SOLO;
-
-    if (gHttpHandler->GetPipelineAggressive() &&
-        info & kPipelineInfoTypeBad &&
-        info != BadExplicitClose &&
-        info != RedVersionTooLow &&
-        info != RedBannedServer &&
-        info != RedCorruptedContent &&
-        info != BadInsufficientFraming) {
-        LOG(("minor negative feedback ignored "
-             "because of pipeline aggressive mode"));
-    }
-    else if (info & kPipelineInfoTypeBad) {
-        if ((info & kPipelineInfoTypeRed) && (mPipelineState != PS_RED)) {
-            LOG(("transition to red from %d. Host = %s.\n",
-                 mPipelineState, mConnInfo->Origin()));
-            mPipelineState = PS_RED;
-            mPipeliningPenalty = 0;
-        }
-
-        if (mLastCreditTime.IsNull())
-            mLastCreditTime = TimeStamp::Now();
-
-        // Red* events impact the host globally via mPipeliningPenalty, while
-        // Bad* events impact the per class penalty.
-
-        // The individual penalties should be < 16bit-signed-maxint - 25000
-        // (approx 7500). Penalties are paid-off either when something promising
-        // happens (a successful transaction, or promising headers) or when
-        // time goes by at a rate of 1 penalty point every 16 seconds.
-
-        switch (info) {
-        case RedVersionTooLow:
-            mPipeliningPenalty += 1000;
-            break;
-        case RedBannedServer:
-            mPipeliningPenalty += 7000;
-            break;
-        case RedCorruptedContent:
-            mPipeliningPenalty += 7000;
-            break;
-        case RedCanceledPipeline:
-            mPipeliningPenalty += 60;
-            break;
-        case BadExplicitClose:
-            mPipeliningClassPenalty[classification] += 250;
-            break;
-        case BadSlowReadMinor:
-            mPipeliningClassPenalty[classification] += 5;
-            break;
-        case BadSlowReadMajor:
-            mPipeliningClassPenalty[classification] += 25;
-            break;
-        case BadInsufficientFraming:
-            mPipeliningClassPenalty[classification] += 7000;
-            break;
-        case BadUnexpectedLarge:
-            mPipeliningClassPenalty[classification] += 120;
-            break;
-
-        default:
-            MOZ_ASSERT(false, "Unknown Bad/Red Pipeline Feedback Event");
-        }
-
-        const int16_t kPenalty = 25000;
-        mPipeliningPenalty = std::min(mPipeliningPenalty, kPenalty);
-        mPipeliningClassPenalty[classification] =
-          std::min(mPipeliningClassPenalty[classification], kPenalty);
-
-        LOG(("Assessing red penalty to %s class %d for event %d. "
-             "Penalty now %d, throttle[%d] = %d\n", mConnInfo->Origin(),
-             classification, info, mPipeliningPenalty, classification,
-             mPipeliningClassPenalty[classification]));
-    }
-    else {
-        // hand out credits for neutral and good events such as
-        // "headers look ok" events
-
-        mPipeliningPenalty = std::max(mPipeliningPenalty - 1, 0);
-        mPipeliningClassPenalty[classification] = std::max(mPipeliningClassPenalty[classification] - 1, 0);
-    }
-
-    if (mPipelineState == PS_RED && !mPipeliningPenalty)
-    {
-        LOG(("transition %s to yellow\n", mConnInfo->Origin()));
-        mPipelineState = PS_YELLOW;
-        mYellowConnection = nullptr;
-    }
-}
-
-void
-nsHttpConnectionMgr::
-nsConnectionEntry::SetYellowConnection(nsHttpConnection *conn)
-{
-    MOZ_ASSERT(!mYellowConnection && mPipelineState == PS_YELLOW,
-               "yellow connection already set or state is not yellow");
-    mYellowConnection = conn;
-    mYellowGoodEvents = mYellowBadEvents = 0;
-}
-
-void
-nsHttpConnectionMgr::
-nsConnectionEntry::OnYellowComplete()
-{
-    if (mPipelineState == PS_YELLOW) {
-        if (mYellowGoodEvents && !mYellowBadEvents) {
-            LOG(("transition %s to green\n", mConnInfo->Origin()));
-            mPipelineState = PS_GREEN;
-            mGreenDepth = mInitialGreenDepth;
-        }
-        else {
-            // The purpose of the yellow state is to witness at least
-            // one successful pipelined transaction without seeing any
-            // kind of negative feedback before opening the flood gates.
-            // If we haven't confirmed that, then transfer back to red.
-            LOG(("transition %s to red from yellow return\n",
-                 mConnInfo->Origin()));
-            mPipelineState = PS_RED;
-        }
-    }
-
-    mYellowConnection = nullptr;
-}
-
-void
-nsHttpConnectionMgr::
-nsConnectionEntry::CreditPenalty()
-{
-    if (mLastCreditTime.IsNull())
-        return;
-
-    // Decrease penalty values by 1 for every 16 seconds
-    // (i.e 3.7 per minute, or 1000 every 4h20m)
-
-    TimeStamp now = TimeStamp::Now();
-    TimeDuration elapsedTime = now - mLastCreditTime;
-    uint32_t creditsEarned =
-        static_cast<uint32_t>(elapsedTime.ToSeconds()) >> 4;
-
-    bool failed = false;
-    if (creditsEarned > 0) {
-        mPipeliningPenalty =
-            std::max(int32_t(mPipeliningPenalty - creditsEarned), 0);
-        if (mPipeliningPenalty > 0)
-            failed = true;
-
-        for (int32_t i = 0; i < nsAHttpTransaction::CLASS_MAX; ++i) {
-            mPipeliningClassPenalty[i]  =
-                std::max(int32_t(mPipeliningClassPenalty[i] - creditsEarned), 0);
-            failed = failed || (mPipeliningClassPenalty[i] > 0);
-        }
-
-        // update last credit mark to reflect elapsed time
-        mLastCreditTime += TimeDuration::FromSeconds(creditsEarned << 4);
-    }
-    else {
-        failed = true;                         /* just assume this */
-    }
-
-    // If we are no longer red then clear the credit counter - you only
-    // get credits for time spent in the red state
-    if (!failed)
-        mLastCreditTime = TimeStamp();    /* reset to null timestamp */
-
-    if (mPipelineState == PS_RED && !mPipeliningPenalty)
-    {
-        LOG(("transition %s to yellow based on time credit\n",
-             mConnInfo->Origin()));
-        mPipelineState = PS_YELLOW;
-        mYellowConnection = nullptr;
-    }
-}
-
-uint32_t
-nsHttpConnectionMgr::
-nsConnectionEntry::MaxPipelineDepth(nsAHttpTransaction::Classifier aClass)
-{
-    // Still subject to configuration limit no matter return value
-
-    if ((mPipelineState == PS_RED) || (mPipeliningClassPenalty[aClass] > 0))
-        return 0;
-
-    if (mPipelineState == PS_YELLOW)
-        return kPipelineRestricted;
-
-    return mGreenDepth;
-}
-
-bool
 nsHttpConnectionMgr::GetConnectionData(nsTArray<HttpRetParams> *aArg)
 {
     for (auto iter = mCT.Iter(); !iter.Done(); iter.Next()) {
         nsAutoPtr<nsConnectionEntry>& ent = iter.Data();
 
         if (ent->mConnInfo->GetPrivate()) {
             continue;
         }
--- a/netwerk/protocol/http/nsHttpConnectionMgr.h
+++ b/netwerk/protocol/http/nsHttpConnectionMgr.h
@@ -43,33 +43,29 @@ public:
     NS_DECL_THREADSAFE_ISUPPORTS
     NS_DECL_NSIOBSERVER
 
     // parameter names
     enum nsParamName {
         MAX_CONNECTIONS,
         MAX_PERSISTENT_CONNECTIONS_PER_HOST,
         MAX_PERSISTENT_CONNECTIONS_PER_PROXY,
-        MAX_REQUEST_DELAY,
-        MAX_PIPELINED_REQUESTS,
-        MAX_OPTIMISTIC_PIPELINED_REQUESTS
+        MAX_REQUEST_DELAY
     };
 
     //-------------------------------------------------------------------------
     // NOTE: functions below may only be called on the main thread.
     //-------------------------------------------------------------------------
 
     nsHttpConnectionMgr();
 
     nsresult Init(uint16_t maxConnections,
                   uint16_t maxPersistentConnectionsPerHost,
                   uint16_t maxPersistentConnectionsPerProxy,
-                  uint16_t maxRequestDelay,
-                  uint16_t maxPipelinedRequests,
-                  uint16_t maxOptimisticPipelinedRequests);
+                  uint16_t maxRequestDelay);
     nsresult Shutdown();
 
     //-------------------------------------------------------------------------
     // NOTE: functions below may be called on any thread.
     //-------------------------------------------------------------------------
 
     // Schedules next pruning of dead connection to happen after
     // given time.
@@ -144,80 +140,16 @@ public:
 
     // called from main thread to post a new request token bucket
     // to the socket thread
     nsresult UpdateRequestTokenBucket(EventTokenBucket *aBucket);
 
     // clears the connection history mCT
     nsresult ClearConnectionHistory();
 
-    // Pipielining Interfaces and Datatypes
-
-    const static uint32_t kPipelineInfoTypeMask = 0xffff0000;
-    const static uint32_t kPipelineInfoIDMask   = ~kPipelineInfoTypeMask;
-
-    const static uint32_t kPipelineInfoTypeRed     = 0x00010000;
-    const static uint32_t kPipelineInfoTypeBad     = 0x00020000;
-    const static uint32_t kPipelineInfoTypeNeutral = 0x00040000;
-    const static uint32_t kPipelineInfoTypeGood    = 0x00080000;
-
-    enum PipelineFeedbackInfoType
-    {
-        // Used when an HTTP response less than 1.1 is received
-        RedVersionTooLow = kPipelineInfoTypeRed | kPipelineInfoTypeBad | 0x0001,
-
-        // Used when a HTTP Server response header that is on the banned from
-        // pipelining list is received
-        RedBannedServer = kPipelineInfoTypeRed | kPipelineInfoTypeBad | 0x0002,
-
-        // Used when a response is terminated early, when it fails an
-        // integrity check such as assoc-req or when a 304 contained a Last-Modified
-        // differnet than the entry being validated.
-        RedCorruptedContent = kPipelineInfoTypeRed | kPipelineInfoTypeBad | 0x0004,
-
-        // Used when a pipeline is only partly satisfied - for instance if the
-        // server closed the connection after responding to the first
-        // request but left some requests unprocessed.
-        RedCanceledPipeline = kPipelineInfoTypeRed | kPipelineInfoTypeBad | 0x0005,
-
-        // Used when a connection that we expected to stay persistently open
-        // was closed by the server. Not used when simply timed out.
-        BadExplicitClose = kPipelineInfoTypeBad | 0x0003,
-
-        // Used when there is a gap of around 400 - 1200ms in between data being
-        // read from the server
-        BadSlowReadMinor = kPipelineInfoTypeBad | 0x0006,
-
-        // Used when there is a gap of > 1200ms in between data being
-        // read from the server
-        BadSlowReadMajor = kPipelineInfoTypeBad | 0x0007,
-
-        // Used when a response is received that is not framed with either chunked
-        // encoding or a complete content length.
-        BadInsufficientFraming = kPipelineInfoTypeBad | 0x0008,
-
-        // Used when a very large response is recevied in a potential pipelining
-        // context. Large responses cause head of line blocking.
-        BadUnexpectedLarge = kPipelineInfoTypeBad | 0x000B,
-
-        // Used when a response is received that has headers that appear to support
-        // pipelining.
-        NeutralExpectedOK = kPipelineInfoTypeNeutral | 0x0009,
-
-        // Used when a response is received successfully to a pipelined request.
-        GoodCompletedOK = kPipelineInfoTypeGood | 0x000A
-    };
-
-    // called to provide information relevant to the pipelining manager
-    // may be called from any thread
-    void     PipelineFeedbackInfo(nsHttpConnectionInfo *,
-                                  PipelineFeedbackInfoType info,
-                                  nsHttpConnection *,
-                                  uint32_t);
-
     void ReportFailedToProcess(nsIURI *uri);
 
     // Causes a large amount of connection diagnostic information to be
     // printed to the javascript console
     void PrintDiagnostics();
 
     //-------------------------------------------------------------------------
     // NOTE: functions below may be called only on the socket thread.
@@ -242,47 +174,28 @@ public:
     // that the network peer has closed the transport.
     nsresult CloseIdleConnection(nsHttpConnection *);
 
     // The connection manager needs to know when a normal HTTP connection has been
     // upgraded to SPDY because the dispatch and idle semantics are a little
     // bit different.
     void ReportSpdyConnection(nsHttpConnection *, bool usingSpdy);
 
-    bool     SupportsPipelining(nsHttpConnectionInfo *);
-
     bool GetConnectionData(nsTArray<HttpRetParams> *);
 
     void ResetIPFamilyPreference(nsHttpConnectionInfo *);
 
     uint16_t MaxRequestDelay() { return mMaxRequestDelay; }
 
     // public, so that the SPDY/http2 seesions can activate
     void ActivateTimeoutTick();
 
 private:
     virtual ~nsHttpConnectionMgr();
 
-    enum PipeliningState {
-        // Host has proven itself pipeline capable through past experience and
-        // large pipeline depths are allowed on multiple connections.
-        PS_GREEN,
-
-        // Not enough information is available yet with this host to be certain
-        // of pipeline capability. Small pipelines on a single connection are
-        // allowed in order to decide whether or not to proceed to green.
-        PS_YELLOW,
-
-        // One or more bad events has happened that indicate that pipelining
-        // to this host (or a particular type of transaction with this host)
-        // is a bad idea. Pipelining is not currently allowed, but time and
-        // other positive experiences will eventually allow it to try again.
-        PS_RED
-    };
-
     class nsHalfOpenSocket;
 
     // nsConnectionEntry
     //
     // mCT maps connection info hash key to nsConnectionEntry object, which
     // contains list of active and idle connections as well as the list of
     // pending transactions.
     //
@@ -302,64 +215,16 @@ private:
 
         // calculate the number of half open sockets that have not had at least 1
         // connection complete
         uint32_t UnconnectedHalfOpens();
 
         // Remove a particular half open socket from the mHalfOpens array
         void RemoveHalfOpen(nsHalfOpenSocket *);
 
-        // Pipeline depths for various states
-        const static uint32_t kPipelineUnlimited  = 1024; // fully open - extended green
-        const static uint32_t kPipelineOpen       = 6;    // 6 on each conn - normal green
-        const static uint32_t kPipelineRestricted = 2;    // 2 on just 1 conn in yellow
-
-        nsHttpConnectionMgr::PipeliningState PipelineState();
-        void OnPipelineFeedbackInfo(
-            nsHttpConnectionMgr::PipelineFeedbackInfoType info,
-            nsHttpConnection *, uint32_t);
-        bool SupportsPipelining();
-        uint32_t MaxPipelineDepth(nsAHttpTransaction::Classifier classification);
-        void CreditPenalty();
-
-        nsHttpConnectionMgr::PipeliningState mPipelineState;
-
-        void SetYellowConnection(nsHttpConnection *);
-        void OnYellowComplete();
-        uint32_t                  mYellowGoodEvents;
-        uint32_t                  mYellowBadEvents;
-        nsHttpConnection         *mYellowConnection;
-
-        // initialGreenDepth is the max depth of a pipeline when you first
-        // transition to green. Normally this is kPipelineOpen, but it can
-        // be kPipelineUnlimited in aggressive mode.
-        uint32_t                  mInitialGreenDepth;
-
-        // greenDepth is the current max allowed depth of a pipeline when
-        // in the green state. Normally this starts as kPipelineOpen and
-        // grows to kPipelineUnlimited after a pipeline of depth 3 has been
-        // successfully transacted.
-        uint32_t                  mGreenDepth;
-
-        // pipeliningPenalty is the current amount of penalty points this host
-        // entry has earned for participating in events that are not conducive
-        // to good pipelines - such as head of line blocking, canceled pipelines,
-        // etc.. penalties are paid back either through elapsed time or simply
-        // healthy transactions. Having penalty points means that this host is
-        // not currently eligible for pipelines.
-        int16_t                   mPipeliningPenalty;
-
-        // some penalty points only apply to particular classifications of
-        // transactions - this allows a server that perhaps has head of line
-        // blocking problems on CGI queries to still serve JS pipelined.
-        int16_t                   mPipeliningClassPenalty[nsAHttpTransaction::CLASS_MAX];
-
-        // for calculating penalty repair credits
-        TimeStamp        mLastCreditTime;
-
         // Spdy sometimes resolves the address in the socket manager in order
         // to re-coalesce sharded HTTP hosts. The dotted decimal address is
         // combined with the Anonymous flag from the connection information
         // to build the hash key for hosts in the same ip pool.
         //
         // When a set of hosts are coalesced together one of them is marked
         // mSpdyPreferred. The mapping is maintained in the connection mananger
         // mSpdyPreferred hash.
@@ -494,42 +359,35 @@ private:
     ReentrantMonitor    mReentrantMonitor;
     nsCOMPtr<nsIEventTarget>     mSocketThreadTarget;
 
     // connection limits
     uint16_t mMaxConns;
     uint16_t mMaxPersistConnsPerHost;
     uint16_t mMaxPersistConnsPerProxy;
     uint16_t mMaxRequestDelay; // in seconds
-    uint16_t mMaxPipelinedRequests;
-    uint16_t mMaxOptimisticPipelinedRequests;
     Atomic<bool, mozilla::Relaxed> mIsShuttingDown;
 
     //-------------------------------------------------------------------------
     // NOTE: these members are only accessed on the socket transport thread
     //-------------------------------------------------------------------------
 
     bool     ProcessPendingQForEntry(nsConnectionEntry *, bool considerAll);
-    bool     IsUnderPressure(nsConnectionEntry *ent,
-                             nsHttpTransaction::Classifier classification);
     bool     AtActiveConnectionLimit(nsConnectionEntry *, uint32_t caps);
     nsresult TryDispatchTransaction(nsConnectionEntry *ent,
                                     bool onlyReusedConnection,
                                     nsHttpTransaction *trans);
     nsresult DispatchTransaction(nsConnectionEntry *,
                                  nsHttpTransaction *,
                                  nsHttpConnection *);
     nsresult DispatchAbstractTransaction(nsConnectionEntry *,
                                          nsAHttpTransaction *,
                                          uint32_t,
                                          nsHttpConnection *,
                                          int32_t);
-    nsresult BuildPipeline(nsConnectionEntry *,
-                           nsAHttpTransaction *,
-                           nsHttpPipeline **);
     bool     RestrictConnections(nsConnectionEntry *);
     nsresult ProcessNewTransaction(nsHttpTransaction *);
     nsresult EnsureSocketThreadTarget();
     void     ClosePersistentConnections(nsConnectionEntry *ent);
     void     ReportProxyTelemetry(nsConnectionEntry *ent);
     nsresult CreateTransport(nsConnectionEntry *, nsAHttpTransaction *,
                              uint32_t, bool, bool, bool);
     void     AddActiveConn(nsHttpConnection *, nsConnectionEntry *);
@@ -537,20 +395,16 @@ private:
     void     StartedConnect();
     void     RecvdConnect();
 
     nsConnectionEntry *GetOrCreateConnectionEntry(nsHttpConnectionInfo *,
                                                   bool allowWildCard);
 
     nsresult MakeNewConnection(nsConnectionEntry *ent,
                                nsHttpTransaction *trans);
-    bool     AddToShortestPipeline(nsConnectionEntry *ent,
-                                   nsHttpTransaction *trans,
-                                   nsHttpTransaction::Classifier classification,
-                                   uint16_t depthLimit);
 
     // Manage the preferred spdy connection entry for this address
     nsConnectionEntry *GetSpdyPreferredEnt(nsConnectionEntry *aOriginalEntry);
     nsConnectionEntry *LookupPreferredHash(nsConnectionEntry *ent);
     void               StorePreferredHash(nsConnectionEntry *ent);
     void               RemovePreferredHash(nsConnectionEntry *ent);
     nsHttpConnection  *GetSpdyPreferredConn(nsConnectionEntry *ent);
     nsDataHashtable<nsCStringHashKey, nsConnectionEntry *>   mSpdyPreferredHash;
--- a/netwerk/protocol/http/nsHttpHandler.cpp
+++ b/netwerk/protocol/http/nsHttpHandler.cpp
@@ -36,17 +36,16 @@
 #include "ASpdySession.h"
 #include "EventTokenBucket.h"
 #include "Tickler.h"
 #include "nsIXULAppInfo.h"
 #include "nsICookieService.h"
 #include "nsIObserverService.h"
 #include "nsISiteSecurityService.h"
 #include "nsIStreamConverterService.h"
-#include "nsITimer.h"
 #include "nsCRT.h"
 #include "nsIMemoryReporter.h"
 #include "nsIParentalControlsService.h"
 #include "nsPIDOMWindow.h"
 #include "nsINetworkLinkService.h"
 #include "nsHttpChannelAuthProvider.h"
 #include "nsServiceManagerUtils.h"
 #include "nsComponentManagerUtils.h"
@@ -169,41 +168,31 @@ nsHttpHandler::nsHttpHandler()
     , mCapabilities(NS_HTTP_ALLOW_KEEPALIVE)
     , mReferrerLevel(0xff) // by default we always send a referrer
     , mSpoofReferrerSource(false)
     , mHideOnionReferrerSource(false)
     , mReferrerTrimmingPolicy(0)
     , mReferrerXOriginTrimmingPolicy(0)
     , mReferrerXOriginPolicy(0)
     , mFastFallbackToIPv4(false)
-    , mProxyPipelining(true)
     , mIdleTimeout(PR_SecondsToInterval(10))
     , mSpdyTimeout(PR_SecondsToInterval(180))
     , mResponseTimeout(PR_SecondsToInterval(300))
     , mResponseTimeoutEnabled(false)
     , mNetworkChangedTimeout(5000)
     , mMaxRequestAttempts(6)
     , mMaxRequestDelay(10)
     , mIdleSynTimeout(250)
     , mH2MandatorySuiteEnabled(false)
-    , mPipeliningEnabled(false)
     , mMaxConnections(24)
     , mMaxPersistentConnectionsPerServer(2)
     , mMaxPersistentConnectionsPerProxy(4)
-    , mMaxPipelinedRequests(32)
-    , mMaxOptimisticPipelinedRequests(4)
-    , mPipelineAggressive(false)
-    , mMaxPipelineObjectSize(300000)
-    , mPipelineRescheduleOnTimeout(true)
-    , mPipelineRescheduleTimeout(PR_MillisecondsToInterval(1500))
-    , mPipelineReadTimeout(PR_MillisecondsToInterval(30000))
     , mRedirectionLimit(10)
     , mPhishyUserPassLength(1)
     , mQoSBits(0x00)
-    , mPipeliningOverSSL(false)
     , mEnforceAssocReq(false)
     , mLastUniqueID(NowInSeconds())
     , mSessionStartTime(0)
     , mLegacyAppName("Mozilla")
     , mLegacyAppVersion("5.0")
     , mProduct("Gecko")
     , mCompatFirefoxEnabled(false)
     , mUserAgentIsDirty(true)
@@ -264,21 +253,16 @@ nsHttpHandler::~nsHttpHandler()
         mConnMgr->Shutdown();
         mConnMgr = nullptr;
     }
 
     // Note: don't call NeckoChild::DestroyNeckoChild() here, as it's too late
     // and it'll segfault.  NeckoChild will get cleaned up by process exit.
 
     nsHttp::DestroyAtomTable();
-    if (mPipelineTestTimer) {
-        mPipelineTestTimer->Cancel();
-        mPipelineTestTimer = nullptr;
-    }
-
     gHttpHandler = nullptr;
 }
 
 nsresult
 nsHttpHandler::Init()
 {
     nsresult rv;
 
@@ -389,21 +373,23 @@ nsHttpHandler::Init()
         // about shutdown ordering.
         obsService->AddObserver(this, "profile-change-net-teardown", true);
         obsService->AddObserver(this, "profile-change-net-restore", true);
         obsService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);
         obsService->AddObserver(this, "net:clear-active-logins", true);
         obsService->AddObserver(this, "net:prune-dead-connections", true);
         // Sent by the TorButton add-on in the Tor Browser
         obsService->AddObserver(this, "net:prune-all-connections", true);
-        obsService->AddObserver(this, "net:failed-to-process-uri-content", true);
         obsService->AddObserver(this, "last-pb-context-exited", true);
         obsService->AddObserver(this, "browser:purge-session-history", true);
         obsService->AddObserver(this, NS_NETWORK_LINK_TOPIC, true);
         obsService->AddObserver(this, "application-background", true);
+
+        // disabled as its a nop right now
+        // obsService->AddObserver(this, "net:failed-to-process-uri-content", true);
     }
 
     MakeNewRequestTokenBucket();
     mWifiTickler = new Tickler();
     if (NS_FAILED(mWifiTickler->Init()))
         mWifiTickler = nullptr;
 
     nsCOMPtr<nsIParentalControlsService> pc = do_CreateInstance("@mozilla.org/parental-controls-service;1");
@@ -438,19 +424,17 @@ nsHttpHandler::InitConnectionMgr()
 
     if (!mConnMgr) {
         mConnMgr = new nsHttpConnectionMgr();
     }
 
     rv = mConnMgr->Init(mMaxConnections,
                         mMaxPersistentConnectionsPerServer,
                         mMaxPersistentConnectionsPerProxy,
-                        mMaxRequestDelay,
-                        mMaxPipelinedRequests,
-                        mMaxOptimisticPipelinedRequests);
+                        mMaxRequestDelay);
     return rv;
 }
 
 nsresult
 nsHttpHandler::AddStandardRequestHeaders(nsHttpRequestHead *request, bool isSecure)
 {
     nsresult rv;
 
@@ -1152,106 +1136,16 @@ nsHttpHandler::PrefsChanged(nsIPrefBranc
             if (!PL_strcmp(httpVersion, "1.1"))
                 mProxyHttpVersion = NS_HTTP_VERSION_1_1;
             else
                 mProxyHttpVersion = NS_HTTP_VERSION_1_0;
             // it does not make sense to issue a HTTP/0.9 request to a proxy server
         }
     }
 
-    if (PREF_CHANGED(HTTP_PREF("pipelining"))) {
-        rv = prefs->GetBoolPref(HTTP_PREF("pipelining"), &cVar);
-        if (NS_SUCCEEDED(rv)) {
-            if (cVar)
-                mCapabilities |=  NS_HTTP_ALLOW_PIPELINING;
-            else
-                mCapabilities &= ~NS_HTTP_ALLOW_PIPELINING;
-            mPipeliningEnabled = cVar;
-        }
-    }
-
-    if (PREF_CHANGED(HTTP_PREF("pipelining.maxrequests"))) {
-        rv = prefs->GetIntPref(HTTP_PREF("pipelining.maxrequests"), &val);
-        if (NS_SUCCEEDED(rv)) {
-            mMaxPipelinedRequests = clamped(val, 1, 0xffff);
-            if (mConnMgr)
-                mConnMgr->UpdateParam(nsHttpConnectionMgr::MAX_PIPELINED_REQUESTS,
-                                      mMaxPipelinedRequests);
-        }
-    }
-
-    if (PREF_CHANGED(HTTP_PREF("pipelining.max-optimistic-requests"))) {
-        rv = prefs->
-            GetIntPref(HTTP_PREF("pipelining.max-optimistic-requests"), &val);
-        if (NS_SUCCEEDED(rv)) {
-            mMaxOptimisticPipelinedRequests = clamped(val, 1, 0xffff);
-            if (mConnMgr)
-                mConnMgr->UpdateParam
-                    (nsHttpConnectionMgr::MAX_OPTIMISTIC_PIPELINED_REQUESTS,
-                     mMaxOptimisticPipelinedRequests);
-        }
-    }
-
-    if (PREF_CHANGED(HTTP_PREF("pipelining.aggressive"))) {
-        rv = prefs->GetBoolPref(HTTP_PREF("pipelining.aggressive"), &cVar);
-        if (NS_SUCCEEDED(rv))
-            mPipelineAggressive = cVar;
-    }
-
-    if (PREF_CHANGED(HTTP_PREF("pipelining.maxsize"))) {
-        rv = prefs->GetIntPref(HTTP_PREF("pipelining.maxsize"), &val);
-        if (NS_SUCCEEDED(rv)) {
-            mMaxPipelineObjectSize =
-                static_cast<int64_t>(clamped(val, 1000, 100000000));
-        }
-    }
-
-    // Determines whether or not to actually reschedule after the
-    // reschedule-timeout has expired
-    if (PREF_CHANGED(HTTP_PREF("pipelining.reschedule-on-timeout"))) {
-        rv = prefs->GetBoolPref(HTTP_PREF("pipelining.reschedule-on-timeout"),
-                                &cVar);
-        if (NS_SUCCEEDED(rv))
-            mPipelineRescheduleOnTimeout = cVar;
-    }
-
-    // The amount of time head of line blocking is allowed (in ms)
-    // before the blocked transactions are moved to another pipeline
-    if (PREF_CHANGED(HTTP_PREF("pipelining.reschedule-timeout"))) {
-        rv = prefs->GetIntPref(HTTP_PREF("pipelining.reschedule-timeout"),
-                               &val);
-        if (NS_SUCCEEDED(rv)) {
-            mPipelineRescheduleTimeout =
-                PR_MillisecondsToInterval((uint16_t) clamped(val, 500, 0xffff));
-        }
-    }
-
-    // The amount of time a pipelined transaction is allowed to wait before
-    // being canceled and retried in a non-pipeline connection
-    if (PREF_CHANGED(HTTP_PREF("pipelining.read-timeout"))) {
-        rv = prefs->GetIntPref(HTTP_PREF("pipelining.read-timeout"), &val);
-        if (NS_SUCCEEDED(rv)) {
-            mPipelineReadTimeout =
-                PR_MillisecondsToInterval((uint16_t) clamped(val, 5000,
-                                                             0xffff));
-        }
-    }
-
-    if (PREF_CHANGED(HTTP_PREF("pipelining.ssl"))) {
-        rv = prefs->GetBoolPref(HTTP_PREF("pipelining.ssl"), &cVar);
-        if (NS_SUCCEEDED(rv))
-            mPipeliningOverSSL = cVar;
-    }
-
-    if (PREF_CHANGED(HTTP_PREF("proxy.pipelining"))) {
-        rv = prefs->GetBoolPref(HTTP_PREF("proxy.pipelining"), &cVar);
-        if (NS_SUCCEEDED(rv))
-            mProxyPipelining = cVar;
-    }
-
     if (PREF_CHANGED(HTTP_PREF("qos"))) {
         rv = prefs->GetIntPref(HTTP_PREF("qos"), &val);
         if (NS_SUCCEEDED(rv))
             mQoSBits = (uint8_t) clamped(val, 0, 0xff);
     }
 
     if (PREF_CHANGED(HTTP_PREF("accept.default"))) {
         nsXPIDLCString accept;
@@ -1575,47 +1469,16 @@ nsHttpHandler::PrefsChanged(nsIPrefBranc
     if (PREF_CHANGED("network.http.debug-observations")) {
         cVar = false;
         rv = prefs->GetBoolPref("network.http.debug-observations", &cVar);
         if (NS_SUCCEEDED(rv)) {
             mDebugObservations = cVar;
         }
     }
 
-    //
-    // Test HTTP Pipelining (bug796192)
-    // If experiments are allowed and pipelining is Off,
-    // turn it On for just 10 minutes
-    //
-    if (mAllowExperiments && !mPipeliningEnabled &&
-        PREF_CHANGED(HTTP_PREF("pipelining.abtest"))) {
-        rv = prefs->GetBoolPref(HTTP_PREF("pipelining.abtest"), &cVar);
-        if (NS_SUCCEEDED(rv)) {
-            // If option is enabled, only test for ~1% of sessions
-            if (cVar && !(rand() % 128)) {
-                mCapabilities |=  NS_HTTP_ALLOW_PIPELINING;
-                if (mPipelineTestTimer)
-                    mPipelineTestTimer->Cancel();
-                mPipelineTestTimer =
-                    do_CreateInstance("@mozilla.org/timer;1", &rv);
-                if (NS_SUCCEEDED(rv)) {
-                    rv = mPipelineTestTimer->InitWithFuncCallback(
-                        TimerCallback, this, 10*60*1000, // 10 minutes
-                        nsITimer::TYPE_ONE_SHOT);
-                }
-            } else {
-                mCapabilities &= ~NS_HTTP_ALLOW_PIPELINING;
-                if (mPipelineTestTimer) {
-                    mPipelineTestTimer->Cancel();
-                    mPipelineTestTimer = nullptr;
-                }
-            }
-        }
-    }
-
     if (PREF_CHANGED(HTTP_PREF("pacing.requests.enabled"))) {
         rv = prefs->GetBoolPref(HTTP_PREF("pacing.requests.enabled"), &cVar);
         if (NS_SUCCEEDED(rv)) {
             mRequestTokenBucketEnabled = cVar;
             requestTokenBucketUpdated = true;
         }
     }
     if (PREF_CHANGED(HTTP_PREF("pacing.requests.min-parallelism"))) {
@@ -1732,27 +1595,16 @@ nsHttpHandler::PrefsChanged(nsIPrefBranc
                               !mTCPKeepaliveLongLivedEnabled;
 
 #undef PREF_CHANGED
 #undef MULTI_PREF_CHANGED
 }
 
 
 /**
- * Static method called by mPipelineTestTimer when it expires.
- */
-void
-nsHttpHandler::TimerCallback(nsITimer * aTimer, void * aClosure)
-{
-    RefPtr<nsHttpHandler> thisObject = static_cast<nsHttpHandler*>(aClosure);
-    if (!thisObject->mPipeliningEnabled)
-        thisObject->mCapabilities &= ~NS_HTTP_ALLOW_PIPELINING;
-}
-
-/**
  * Currently, only regularizes the case of subtags.
  */
 static void
 CanonicalizeLanguageTag(char *languageTag)
 {
     char *s = languageTag;
     while (*s != '\0') {
         *s = nsCRT::ToLower(*s);
@@ -2043,22 +1895,16 @@ nsHttpHandler::NewProxiedChannel2(nsIURI
     if (IsNeckoChild()) {
         httpChannel = new HttpChannelChild();
     } else {
         httpChannel = new nsHttpChannel();
     }
 
     uint32_t caps = mCapabilities;
 
-    if (https) {
-        // enable pipelining over SSL if requested
-        if (mPipeliningOverSSL)
-            caps |= NS_HTTP_ALLOW_PIPELINING;
-    }
-
     if (!IsNeckoChild()) {
         // HACK: make sure PSM gets initialized on the main thread.
         net_EnsurePSMInit();
     }
 
     nsID channelId;
     rv = NewChannelId(&channelId);
     NS_ENSURE_SUCCESS(rv, rv);
@@ -2186,21 +2032,22 @@ nsHttpHandler::Observe(nsISupports *subj
         if (mConnMgr) {
             mConnMgr->PruneDeadConnections();
         }
     } else if (!strcmp(topic, "net:prune-all-connections")) {
         if (mConnMgr) {
             mConnMgr->DoShiftReloadConnectionCleanup(nullptr);
             mConnMgr->PruneDeadConnections();
         }
+#if 0
     } else if (!strcmp(topic, "net:failed-to-process-uri-content")) {
-        nsCOMPtr<nsIURI> uri = do_QueryInterface(subject);
-        if (uri && mConnMgr) {
-            mConnMgr->ReportFailedToProcess(uri);
-        }
+         // nop right now - we used to cancel h1 pipelines based on this,
+         // but those are no longer implemented
+         nsCOMPtr<nsIURI> uri = do_QueryInterface(subject);
+#endif
     } else if (!strcmp(topic, "last-pb-context-exited")) {
         mPrivateAuthCache.ClearAll();
         if (mConnMgr) {
             mConnMgr->ClearAltServiceMappings();
         }
     } else if (!strcmp(topic, "browser:purge-session-history")) {
         if (mConnMgr) {
             if (gSocketTransportService) {
--- a/netwerk/protocol/http/nsHttpHandler.h
+++ b/netwerk/protocol/http/nsHttpHandler.h
@@ -23,17 +23,16 @@ class nsIHttpChannel;
 class nsIPrefBranch;
 class nsICancelable;
 class nsICookieService;
 class nsIIOService;
 class nsIRequestContextService;
 class nsISiteSecurityService;
 class nsIStreamConverterService;
 class nsIThrottlingService;
-class nsITimer;
 class nsIUUIDGenerator;
 
 
 namespace mozilla {
 namespace net {
 
 extern Atomic<PRThread*, Relaxed> gSocketThread;
 
@@ -97,17 +96,16 @@ public:
     PRIntervalTime ResponseTimeoutEnabled()  { return mResponseTimeoutEnabled; }
     uint32_t       NetworkChangedTimeout()   { return mNetworkChangedTimeout; }
     uint16_t       MaxRequestAttempts()      { return mMaxRequestAttempts; }
     const char    *DefaultSocketType()       { return mDefaultSocketType.get(); /* ok to return null */ }
     uint32_t       PhishyUserPassLength()    { return mPhishyUserPassLength; }
     uint8_t        GetQoSBits()              { return mQoSBits; }
     uint16_t       GetIdleSynTimeout()       { return mIdleSynTimeout; }
     bool           FastFallbackToIPv4()      { return mFastFallbackToIPv4; }
-    bool           ProxyPipelining()         { return mProxyPipelining; }
     uint32_t       MaxSocketCount();
     bool           EnforceAssocReq()         { return mEnforceAssocReq; }
 
     bool           IsPersistentHttpsCachingEnabled() { return mEnablePersistentHttpsCaching; }
     bool           IsTelemetryEnabled() { return mTelemetryEnabled; }
     bool           AllowExperiments() { return mTelemetryEnabled && mAllowExperiments; }
 
     bool           IsSpdyEnabled() { return mEnableSpdy; }
@@ -314,38 +312,16 @@ public:
         NotifyObservers(chan, NS_HTTP_ON_EXAMINE_CACHED_RESPONSE_TOPIC);
     }
 
     // Generates the host:port string for use in the Host: header as well as the
     // CONNECT line for proxies. This handles IPv6 literals correctly.
     static nsresult GenerateHostPort(const nsCString& host, int32_t port,
                                      nsACString& hostLine);
 
-    bool GetPipelineAggressive()     { return mPipelineAggressive; }
-    void GetMaxPipelineObjectSize(int64_t *outVal)
-    {
-        *outVal = mMaxPipelineObjectSize;
-    }
-
-    bool GetPipelineEnabled()
-    {
-        return mCapabilities & NS_HTTP_ALLOW_PIPELINING;
-    }
-
-    bool GetPipelineRescheduleOnTimeout()
-    {
-        return mPipelineRescheduleOnTimeout;
-    }
-
-    PRIntervalTime GetPipelineRescheduleTimeout()
-    {
-        return mPipelineRescheduleTimeout;
-    }
-
-    PRIntervalTime GetPipelineTimeout()   { return mPipelineReadTimeout; }
 
     SpdyInformation *SpdyInfo() { return &mSpdyInfo; }
     bool IsH2MandatorySuiteEnabled() { return mH2MandatorySuiteEnabled; }
 
     // Returns true if content-signature test pref is set such that they are
     // NOT enforced on remote newtabs.
     bool NewTabContentSignaturesDisabled()
     {
@@ -396,17 +372,16 @@ private:
     nsresult SetAccept(const char *);
     nsresult SetAcceptLanguages(const char *);
     nsresult SetAcceptEncodings(const char *, bool mIsSecure);
 
     nsresult InitConnectionMgr();
 
     void     NotifyObservers(nsIHttpChannel *chan, const char *event);
 
-    static void TimerCallback(nsITimer * aTimer, void * aClosure);
 private:
 
     // cached services
     nsMainThreadPtrHandle<nsIIOService>              mIOService;
     nsMainThreadPtrHandle<nsIStreamConverterService> mStreamConvSvc;
     nsMainThreadPtrHandle<nsICookieService>          mCookieService;
     nsMainThreadPtrHandle<nsISiteSecurityService>    mSSService;
     nsMainThreadPtrHandle<nsIThrottlingService>      mThrottlingService;
@@ -428,51 +403,40 @@ private:
     uint8_t  mReferrerLevel;
     uint8_t  mSpoofReferrerSource;
     uint8_t  mHideOnionReferrerSource;
     uint8_t  mReferrerTrimmingPolicy;
     uint8_t  mReferrerXOriginTrimmingPolicy;
     uint8_t  mReferrerXOriginPolicy;
 
     bool mFastFallbackToIPv4;
-    bool mProxyPipelining;
     PRIntervalTime mIdleTimeout;
     PRIntervalTime mSpdyTimeout;
     PRIntervalTime mResponseTimeout;
     bool mResponseTimeoutEnabled;
     uint32_t mNetworkChangedTimeout; // milliseconds
     uint16_t mMaxRequestAttempts;
     uint16_t mMaxRequestDelay;
     uint16_t mIdleSynTimeout;
 
     bool     mH2MandatorySuiteEnabled;
-    bool     mPipeliningEnabled;
     uint16_t mMaxConnections;
     uint8_t  mMaxPersistentConnectionsPerServer;
     uint8_t  mMaxPersistentConnectionsPerProxy;
-    uint16_t mMaxPipelinedRequests;
-    uint16_t mMaxOptimisticPipelinedRequests;
-    bool     mPipelineAggressive;
-    int64_t  mMaxPipelineObjectSize;
-    bool     mPipelineRescheduleOnTimeout;
-    PRIntervalTime mPipelineRescheduleTimeout;
-    PRIntervalTime mPipelineReadTimeout;
-    nsCOMPtr<nsITimer> mPipelineTestTimer;
 
     uint8_t  mRedirectionLimit;
 
     // we'll warn the user if we load an URL containing a userpass field
     // unless its length is less than this threshold.  this warning is
     // intended to protect the user against spoofing attempts that use
     // the userpass field of the URL to obscure the actual origin server.
     uint8_t  mPhishyUserPassLength;
 
     uint8_t  mQoSBits;
 
-    bool mPipeliningOverSSL;
     bool mEnforceAssocReq;
 
     nsCString mAccept;
     nsCString mAcceptLanguages;
     nsCString mHttpAcceptEncodings;
     nsCString mHttpsAcceptEncodings;
 
     nsXPIDLCString mDefaultSocketType;
deleted file mode 100644
--- a/netwerk/protocol/http/nsHttpPipeline.cpp
+++ /dev/null
@@ -1,912 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-// HttpLog.h should generally be included first
-#include "HttpLog.h"
-
-#include "nsHttpPipeline.h"
-#include "nsHttpHandler.h"
-#include "nsIOService.h"
-#include "nsISocketTransport.h"
-#include "nsIPipe.h"
-#include "nsCOMPtr.h"
-#include "nsSocketTransportService2.h"
-#include <algorithm>
-
-#ifdef DEBUG
-#include "prthread.h"
-#endif
-
-namespace mozilla {
-namespace net {
-
-//-----------------------------------------------------------------------------
-// nsHttpPushBackWriter
-//-----------------------------------------------------------------------------
-
-class nsHttpPushBackWriter : public nsAHttpSegmentWriter
-{
-public:
-    nsHttpPushBackWriter(const char *buf, uint32_t bufLen)
-        : mBuf(buf)
-        , mBufLen(bufLen)
-        { }
-    virtual ~nsHttpPushBackWriter() {}
-
-    nsresult OnWriteSegment(char *buf, uint32_t count, uint32_t *countWritten)
-    {
-        if (mBufLen == 0)
-            return NS_BASE_STREAM_CLOSED;
-
-        if (count > mBufLen)
-            count = mBufLen;
-
-        memcpy(buf, mBuf, count);
-
-        mBuf += count;
-        mBufLen -= count;
-        *countWritten = count;
-        return NS_OK;
-    }
-
-private:
-    const char *mBuf;
-    uint32_t    mBufLen;
-};
-
-//-----------------------------------------------------------------------------
-// nsHttpPipeline <public>
-//-----------------------------------------------------------------------------
-
-nsHttpPipeline::nsHttpPipeline()
-    : mStatus(NS_OK)
-    , mRequestIsPartial(false)
-    , mResponseIsPartial(false)
-    , mClosed(false)
-    , mUtilizedPipeline(false)
-    , mPushBackBuf(nullptr)
-    , mPushBackLen(0)
-    , mPushBackMax(0)
-    , mHttp1xTransactionCount(0)
-    , mReceivingFromProgress(0)
-    , mSendingToProgress(0)
-    , mSuppressSendEvents(true)
-{
-}
-
-nsHttpPipeline::~nsHttpPipeline()
-{
-    // make sure we aren't still holding onto any transactions!
-    Close(NS_ERROR_ABORT);
-
-    if (mPushBackBuf)
-        free(mPushBackBuf);
-}
-
-nsresult
-nsHttpPipeline::AddTransaction(nsAHttpTransaction *trans)
-{
-    LOG(("nsHttpPipeline::AddTransaction [this=%p trans=%p]\n", this, trans));
-
-    if (mRequestQ.Length() || mResponseQ.Length())
-        mUtilizedPipeline = true;
-
-    // A reference to the actual transaction is held by the pipeline transaction
-    // in either the request or response queue
-    mRequestQ.AppendElement(trans);
-    uint32_t qlen = PipelineDepth();
-
-    if (qlen != 1) {
-        trans->SetPipelinePosition(qlen);
-    }
-    else {
-        // do it for this case in case an idempotent cancellation
-        // is being repeated and an old value needs to be cleared
-        trans->SetPipelinePosition(0);
-    }
-
-    // trans->SetConnection() needs to be updated to point back at
-    // the pipeline object.
-    trans->SetConnection(this);
-
-    if (mConnection && !mClosed && mRequestQ.Length() == 1)
-        mConnection->ResumeSend();
-
-    return NS_OK;
-}
-
-uint32_t
-nsHttpPipeline::PipelineDepth()
-{
-    return mRequestQ.Length() + mResponseQ.Length();
-}
-
-nsresult
-nsHttpPipeline::SetPipelinePosition(int32_t position)
-{
-    nsAHttpTransaction *trans = Response(0);
-    if (trans)
-        return trans->SetPipelinePosition(position);
-    return NS_OK;
-}
-
-int32_t
-nsHttpPipeline::PipelinePosition()
-{
-    nsAHttpTransaction *trans = Response(0);
-    if (trans)
-        return trans->PipelinePosition();
-
-    // The response queue is empty, so return oldest request
-    if (mRequestQ.Length())
-        return Request(mRequestQ.Length() - 1)->PipelinePosition();
-
-    // No transactions in the pipeline
-    return 0;
-}
-
-nsHttpPipeline *
-nsHttpPipeline::QueryPipeline()
-{
-    return this;
-}
-
-//-----------------------------------------------------------------------------
-// nsHttpPipeline::nsISupports
-//-----------------------------------------------------------------------------
-
-NS_IMPL_ADDREF(nsHttpPipeline)
-NS_IMPL_RELEASE(nsHttpPipeline)
-
-// multiple inheritance fun :-)
-NS_INTERFACE_MAP_BEGIN(nsHttpPipeline)
-    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsAHttpConnection)
-NS_INTERFACE_MAP_END
-
-
-//-----------------------------------------------------------------------------
-// nsHttpPipeline::nsAHttpConnection
-//-----------------------------------------------------------------------------
-
-nsresult
-nsHttpPipeline::OnHeadersAvailable(nsAHttpTransaction *trans,
-                                   nsHttpRequestHead *requestHead,
-                                   nsHttpResponseHead *responseHead,
-                                   bool *reset)
-{
-    LOG(("nsHttpPipeline::OnHeadersAvailable [this=%p]\n", this));
-
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-    MOZ_ASSERT(mConnection, "no connection");
-
-    RefPtr<nsHttpConnectionInfo> ci;
-    GetConnectionInfo(getter_AddRefs(ci));
-    MOZ_ASSERT(ci);
-
-    if (!ci) {
-        return NS_ERROR_UNEXPECTED;
-    }
-
-    bool pipeliningBefore = gHttpHandler->ConnMgr()->SupportsPipelining(ci);
-
-    // trans has now received its response headers; forward to the real connection
-    nsresult rv = mConnection->OnHeadersAvailable(trans,
-                                                  requestHead,
-                                                  responseHead,
-                                                  reset);
-
-    if (!pipeliningBefore && gHttpHandler->ConnMgr()->SupportsPipelining(ci)) {
-        // The received headers have expanded the eligible
-        // pipeline depth for this connection
-        gHttpHandler->ConnMgr()->ProcessPendingQForEntry(ci);
-    }
-
-    return rv;
-}
-
-void
-nsHttpPipeline::CloseTransaction(nsAHttpTransaction *aTrans, nsresult reason)
-{
-    LOG(("nsHttpPipeline::CloseTransaction [this=%p trans=%p reason=%" PRIx32 "]\n",
-         this, aTrans, static_cast<uint32_t>(reason)));
-
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-    MOZ_ASSERT(NS_FAILED(reason), "expecting failure code");
-
-    // the specified transaction is to be closed with the given "reason"
-    RefPtr<nsAHttpTransaction> trans(aTrans);
-    int32_t index;
-    bool killPipeline = false;
-
-    if ((index = mRequestQ.IndexOf(trans)) >= 0) {
-        if (index == 0 && mRequestIsPartial) {
-            // the transaction is in the request queue.  check to see if any of
-            // its data has been written out yet.
-            killPipeline = true;
-        }
-        mRequestQ.RemoveElementAt(index);
-    } else if ((index = mResponseQ.IndexOf(trans)) >= 0) {
-        mResponseQ.RemoveElementAt(index);
-        // while we could avoid killing the pipeline if this transaction is the
-        // last transaction in the pipeline, there doesn't seem to be that much
-        // value in doing so.  most likely if this transaction is going away,
-        // the others will be shortly as well.
-        killPipeline = true;
-    }
-
-    // Marking this connection as non-reusable prevents other items from being
-    // added to it and causes it to be torn down soon.
-    DontReuse();
-
-    trans->Close(reason);
-    trans = nullptr;
-
-    if (killPipeline) {
-        // reschedule anything from this pipeline onto a different connection
-        CancelPipeline(reason);
-    }
-
-    // If all the transactions have been removed then we can close the connection
-    // right away.
-    if (!mRequestQ.Length() && !mResponseQ.Length() && mConnection)
-        mConnection->CloseTransaction(this, reason);
-}
-
-nsresult
-nsHttpPipeline::TakeTransport(nsISocketTransport  **aTransport,
-                              nsIAsyncInputStream **aInputStream,
-                              nsIAsyncOutputStream **aOutputStream)
-{
-    return mConnection->TakeTransport(aTransport, aInputStream, aOutputStream);
-}
-
-bool
-nsHttpPipeline::IsPersistent()
-{
-    return true; // pipelining requires this
-}
-
-bool
-nsHttpPipeline::IsReused()
-{
-    if (!mUtilizedPipeline && mConnection)
-        return mConnection->IsReused();
-    return true;
-}
-
-void
-nsHttpPipeline::DontReuse()
-{
-    if (mConnection)
-        mConnection->DontReuse();
-}
-
-nsresult
-nsHttpPipeline::PushBack(const char *data, uint32_t length)
-{
-    LOG(("nsHttpPipeline::PushBack [this=%p len=%u]\n", this, length));
-
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-    MOZ_ASSERT(mPushBackLen == 0, "push back buffer already has data!");
-
-    // If we have no chance for a pipeline (e.g. due to an Upgrade)
-    // then push this data down to original connection
-    if (!mConnection->IsPersistent())
-        return mConnection->PushBack(data, length);
-
-    // PushBack is called recursively from WriteSegments
-
-    // XXX we have a design decision to make here.  either we buffer the data
-    // and process it when we return to WriteSegments, or we attempt to move
-    // onto the next transaction from here.  doing so adds complexity with the
-    // benefit of eliminating the extra buffer copy.  the buffer is at most
-    // 4096 bytes, so it is really unclear if there is any value in the added
-    // complexity.  besides simplicity, buffering this data has the advantage
-    // that we'll call close on the transaction sooner, which will wake up
-    // the HTTP channel sooner to continue with its work.
-
-    if (!mPushBackBuf) {
-        mPushBackMax = length;
-        mPushBackBuf = (char *) malloc(mPushBackMax);
-        if (!mPushBackBuf)
-            return NS_ERROR_OUT_OF_MEMORY;
-    }
-    else if (length > mPushBackMax) {
-        // grow push back buffer as necessary.
-        MOZ_ASSERT(length <= nsIOService::gDefaultSegmentSize, "too big");
-        mPushBackMax = length;
-        mPushBackBuf = (char *) realloc(mPushBackBuf, mPushBackMax);
-        if (!mPushBackBuf)
-            return NS_ERROR_OUT_OF_MEMORY;
-    }
-
-    memcpy(mPushBackBuf, data, length);
-    mPushBackLen = length;
-
-    return NS_OK;
-}
-
-already_AddRefed<nsHttpConnection>
-nsHttpPipeline::TakeHttpConnection()
-{
-    if (mConnection)
-        return mConnection->TakeHttpConnection();
-    return nullptr;
-}
-
-nsAHttpTransaction::Classifier
-nsHttpPipeline::Classification()
-{
-    if (mConnection)
-        return mConnection->Classification();
-
-    LOG(("nsHttpPipeline::Classification this=%p "
-         "has null mConnection using CLASS_SOLO default", this));
-    return nsAHttpTransaction::CLASS_SOLO;
-}
-
-void
-nsHttpPipeline::SetProxyConnectFailed()
-{
-    nsAHttpTransaction *trans = Request(0);
-
-    if (trans)
-        trans->SetProxyConnectFailed();
-}
-
-nsHttpRequestHead *
-nsHttpPipeline::RequestHead()
-{
-    nsAHttpTransaction *trans = Request(0);
-
-    if (trans)
-        return trans->RequestHead();
-    return nullptr;
-}
-
-uint32_t
-nsHttpPipeline::Http1xTransactionCount()
-{
-  return mHttp1xTransactionCount;
-}
-
-nsresult
-nsHttpPipeline::TakeSubTransactions(
-    nsTArray<RefPtr<nsAHttpTransaction> > &outTransactions)
-{
-    LOG(("nsHttpPipeline::TakeSubTransactions [this=%p]\n", this));
-
-    if (mResponseQ.Length() || mRequestIsPartial)
-        return NS_ERROR_ALREADY_OPENED;
-
-    int32_t i, count = mRequestQ.Length();
-    for (i = 0; i < count; ++i) {
-        nsAHttpTransaction *trans = Request(i);
-        // set the transaction connection object back to the underlying
-        // nsHttpConnectionHandle
-        trans->SetConnection(mConnection);
-        outTransactions.AppendElement(trans);
-    }
-    mRequestQ.Clear();
-
-    LOG(("   took %d\n", count));
-    return NS_OK;
-}
-
-//-----------------------------------------------------------------------------
-// nsHttpPipeline::nsAHttpTransaction
-//-----------------------------------------------------------------------------
-
-void
-nsHttpPipeline::SetConnection(nsAHttpConnection *conn)
-{
-    LOG(("nsHttpPipeline::SetConnection [this=%p conn=%p]\n", this, conn));
-
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-    MOZ_ASSERT(!conn || !mConnection, "already have a connection");
-
-    mConnection = conn;
-}
-
-nsAHttpConnection *
-nsHttpPipeline::Connection()
-{
-    LOG(("nsHttpPipeline::Connection [this=%p conn=%p]\n", this, mConnection.get()));
-
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-    return mConnection;
-}
-
-void
-nsHttpPipeline::GetSecurityCallbacks(nsIInterfaceRequestor **result)
-{
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-
-    // depending on timing this could be either the request or the response
-    // that is needed - but they both go to the same host. A request for these
-    // callbacks directly in nsHttpTransaction would not make a distinction
-    // over whether the the request had been transmitted yet.
-    nsAHttpTransaction *trans = Request(0);
-    if (!trans)
-        trans = Response(0);
-    if (trans)
-        trans->GetSecurityCallbacks(result);
-    else {
-        *result = nullptr;
-    }
-}
-
-void
-nsHttpPipeline::OnTransportStatus(nsITransport* transport,
-                                  nsresult status, int64_t progress)
-{
-    LOG(("nsHttpPipeline::OnStatus [this=%p status=%" PRIx32 " progress=%" PRId64 "]\n",
-         this, static_cast<uint32_t>(status), progress));
-
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-
-    nsAHttpTransaction *trans;
-    int32_t i, count;
-
-    switch (status) {
-
-    case NS_NET_STATUS_RESOLVING_HOST:
-    case NS_NET_STATUS_RESOLVED_HOST:
-    case NS_NET_STATUS_CONNECTING_TO:
-    case NS_NET_STATUS_CONNECTED_TO:
-        // These should only appear at most once per pipeline.
-        // Deliver to the first transaction.
-
-        trans = Request(0);
-        if (!trans)
-            trans = Response(0);
-        if (trans)
-            trans->OnTransportStatus(transport, status, progress);
-
-        break;
-
-    case NS_NET_STATUS_SENDING_TO:
-        // This is generated by the socket transport when (part) of
-        // a transaction is written out
-        //
-        // In pipelining this is generated out of FillSendBuf(), but it cannot do
-        // so until the connection is confirmed by CONNECTED_TO.
-        // See patch for bug 196827.
-        //
-
-        if (mSuppressSendEvents) {
-            mSuppressSendEvents = false;
-
-            // catch up by sending the event to all the transactions that have
-            // moved from request to response and any that have been partially
-            // sent. Also send WAITING_FOR to those that were completely sent
-            count = mResponseQ.Length();
-            for (i = 0; i < count; ++i) {
-                Response(i)->OnTransportStatus(transport,
-                                               NS_NET_STATUS_SENDING_TO,
-                                               progress);
-                Response(i)->OnTransportStatus(transport,
-                                               NS_NET_STATUS_WAITING_FOR,
-                                               progress);
-            }
-            if (mRequestIsPartial && Request(0))
-                Request(0)->OnTransportStatus(transport,
-                                              NS_NET_STATUS_SENDING_TO,
-                                              progress);
-            mSendingToProgress = progress;
-        }
-        // otherwise ignore it
-        break;
-
-    case NS_NET_STATUS_WAITING_FOR:
-        // Created by nsHttpConnection when request pipeline has been totally
-        // sent. Ignore it here because it is simulated in FillSendBuf() when
-        // a request is moved from request to response.
-
-        // ignore it
-        break;
-
-    case NS_NET_STATUS_RECEIVING_FROM:
-        // Forward this only to the transaction currently recieving data. It is
-        // normally generated by the socket transport, but can also
-        // be repeated by the pushbackwriter if necessary.
-        mReceivingFromProgress = progress;
-        if (Response(0))
-            Response(0)->OnTransportStatus(transport, status, progress);
-        break;
-
-    default:
-        // forward other notifications to all request transactions
-        count = mRequestQ.Length();
-        for (i = 0; i < count; ++i)
-            Request(i)->OnTransportStatus(transport, status, progress);
-        break;
-    }
-}
-
-nsHttpConnectionInfo *
-nsHttpPipeline::ConnectionInfo()
-{
-    nsAHttpTransaction *trans = Request(0) ? Request(0) : Response(0);
-    if (!trans) {
-        return nullptr;
-    }
-    return trans->ConnectionInfo();
-}
-
-bool
-nsHttpPipeline::IsDone()
-{
-    bool done = true;
-
-    uint32_t i, count = mRequestQ.Length();
-    for (i = 0; done && (i < count); i++)
-        done = Request(i)->IsDone();
-
-    count = mResponseQ.Length();
-    for (i = 0; done && (i < count); i++)
-        done = Response(i)->IsDone();
-
-    return done;
-}
-
-nsresult
-nsHttpPipeline::Status()
-{
-    return mStatus;
-}
-
-uint32_t
-nsHttpPipeline::Caps()
-{
-    nsAHttpTransaction *trans = Request(0);
-    if (!trans)
-        trans = Response(0);
-
-    return trans ? trans->Caps() : 0;
-}
-
-void
-nsHttpPipeline::SetDNSWasRefreshed()
-{
-    nsAHttpTransaction *trans = Request(0);
-    if (!trans)
-        trans = Response(0);
-
-    if (trans)
-      trans->SetDNSWasRefreshed();
-}
-
-uint64_t
-nsHttpPipeline::Available()
-{
-    uint64_t result = 0;
-
-    int32_t i, count = mRequestQ.Length();
-    for (i=0; i<count; ++i)
-        result += Request(i)->Available();
-    return result;
-}
-
-nsresult
-nsHttpPipeline::ReadFromPipe(nsIInputStream *stream,
-                             void *closure,
-                             const char *buf,
-                             uint32_t offset,
-                             uint32_t count,
-                             uint32_t *countRead)
-{
-    nsHttpPipeline *self = (nsHttpPipeline *) closure;
-    return self->mReader->OnReadSegment(buf, count, countRead);
-}
-
-nsresult
-nsHttpPipeline::ReadSegments(nsAHttpSegmentReader *reader,
-                             uint32_t count,
-                             uint32_t *countRead)
-{
-    LOG(("nsHttpPipeline::ReadSegments [this=%p count=%u]\n", this, count));
-
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-
-    if (mClosed) {
-        *countRead = 0;
-        return mStatus;
-    }
-
-    nsresult rv;
-    uint64_t avail = 0;
-    if (mSendBufIn) {
-        rv = mSendBufIn->Available(&avail);
-        if (NS_FAILED(rv)) return rv;
-    }
-
-    if (avail == 0) {
-        rv = FillSendBuf();
-        if (NS_FAILED(rv)) return rv;
-
-        rv = mSendBufIn->Available(&avail);
-        if (NS_FAILED(rv)) return rv;
-
-        // return EOF if send buffer is empty
-        if (avail == 0) {
-            *countRead = 0;
-            return NS_OK;
-        }
-    }
-
-    // read no more than what was requested
-    if (avail > count)
-        avail = count;
-
-    mReader = reader;
-
-    // avail is under 4GB, so casting to uint32_t is safe
-    rv = mSendBufIn->ReadSegments(ReadFromPipe, this, (uint32_t)avail, countRead);
-
-    mReader = nullptr;
-    return rv;
-}
-
-nsresult
-nsHttpPipeline::WriteSegments(nsAHttpSegmentWriter *writer,
-                              uint32_t count,
-                              uint32_t *countWritten)
-{
-    LOG(("nsHttpPipeline::WriteSegments [this=%p count=%u]\n", this, count));
-
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-
-    if (mClosed)
-        return NS_SUCCEEDED(mStatus) ? NS_BASE_STREAM_CLOSED : mStatus;
-
-    nsAHttpTransaction *trans;
-    nsresult rv;
-
-    trans = Response(0);
-    // This code deals with the establishment of a CONNECT tunnel through
-    // an HTTP proxy. It allows the connection to do the CONNECT/200
-    // HTTP transaction to establish a tunnel as a precursor to the
-    // actual pipeline of regular HTTP transactions.
-    if (!trans && mRequestQ.Length() &&
-        mConnection->IsProxyConnectInProgress()) {
-        LOG(("nsHttpPipeline::WriteSegments [this=%p] Forced Delegation\n",
-             this));
-        trans = Request(0);
-    }
-
-    if (!trans) {
-        if (mRequestQ.Length() > 0)
-            rv = NS_BASE_STREAM_WOULD_BLOCK;
-        else
-            rv = NS_BASE_STREAM_CLOSED;
-    } else {
-        //
-        // ask the transaction to consume data from the connection.
-        // PushBack may be called recursively.
-        //
-        rv = trans->WriteSegments(writer, count, countWritten);
-
-        if (rv == NS_BASE_STREAM_CLOSED || trans->IsDone()) {
-            trans->Close(NS_OK);
-
-            // Release the transaction if it is not IsProxyConnectInProgress()
-            if (trans == Response(0)) {
-                mResponseQ.RemoveElementAt(0);
-                mResponseIsPartial = false;
-                ++mHttp1xTransactionCount;
-            }
-
-            // ask the connection manager to add additional transactions
-            // to our pipeline.
-            RefPtr<nsHttpConnectionInfo> ci;
-            GetConnectionInfo(getter_AddRefs(ci));
-            if (ci)
-                gHttpHandler->ConnMgr()->ProcessPendingQForEntry(ci);
-        }
-        else
-            mResponseIsPartial = true;
-    }
-
-    if (mPushBackLen) {
-        nsHttpPushBackWriter pushBackWriter(mPushBackBuf, mPushBackLen);
-        uint32_t len = mPushBackLen, n;
-        mPushBackLen = 0;
-
-        // This progress notification has previously been sent from
-        // the socket transport code, but it was delivered to the
-        // previous transaction on the pipeline.
-        nsITransport *transport = Transport();
-        if (transport)
-            OnTransportStatus(transport, NS_NET_STATUS_RECEIVING_FROM,
-                              mReceivingFromProgress);
-
-        // the push back buffer is never larger than NS_HTTP_SEGMENT_SIZE,
-        // so we are guaranteed that the next response will eat the entire
-        // push back buffer (even though it might again call PushBack).
-        rv = WriteSegments(&pushBackWriter, len, &n);
-    }
-
-    return rv;
-}
-
-uint32_t
-nsHttpPipeline::CancelPipeline(nsresult originalReason)
-{
-    uint32_t i, reqLen, respLen, total;
-    nsAHttpTransaction *trans;
-
-    reqLen = mRequestQ.Length();
-    respLen = mResponseQ.Length();
-    total = reqLen + respLen;
-
-    // don't count the first response, if presnet
-    if (respLen)
-        total--;
-
-    if (!total)
-        return 0;
-
-    // any pending requests can ignore this error and be restarted
-    // unless it is during a CONNECT tunnel request
-    for (i = 0; i < reqLen; ++i) {
-        trans = Request(i);
-        if (mConnection && mConnection->IsProxyConnectInProgress())
-            trans->Close(originalReason);
-        else
-            trans->Close(NS_ERROR_NET_RESET);
-    }
-    mRequestQ.Clear();
-
-    // any pending responses can be restarted except for the first one,
-    // that we might want to finish on this pipeline or cancel individually.
-    // Higher levels of callers ensure that we don't process non-idempotent
-    // tranasction with the NS_HTTP_ALLOW_PIPELINING bit set
-    for (i = 1; i < respLen; ++i) {
-        trans = Response(i);
-        trans->Close(NS_ERROR_NET_RESET);
-    }
-
-    if (respLen > 1)
-        mResponseQ.TruncateLength(1);
-
-    DontReuse();
-    Classify(nsAHttpTransaction::CLASS_SOLO);
-
-    return total;
-}
-
-void
-nsHttpPipeline::Close(nsresult reason)
-{
-    LOG(("nsHttpPipeline::Close [this=%p reason=%" PRIx32 "]\n",
-         this, static_cast<uint32_t>(reason)));
-
-    if (mClosed) {
-        LOG(("  already closed\n"));
-        return;
-    }
-
-    // the connection is going away!
-    mStatus = reason;
-    mClosed = true;
-
-    RefPtr<nsHttpConnectionInfo> ci;
-    GetConnectionInfo(getter_AddRefs(ci));
-    uint32_t numRescheduled = CancelPipeline(reason);
-
-    // numRescheduled can be 0 if there is just a single response in the
-    // pipeline object. That isn't really a meaningful pipeline that
-    // has been forced to be rescheduled so it does not need to generate
-    // negative feedback.
-    if (ci && numRescheduled)
-        gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-            ci, nsHttpConnectionMgr::RedCanceledPipeline, nullptr, 0);
-
-    nsAHttpTransaction *trans = Response(0);
-    if (!trans)
-        return;
-
-    // The current transaction can be restarted via reset
-    // if the response has not started to arrive and the reason
-    // for failure is innocuous (e.g. not an SSL error)
-    if (!mResponseIsPartial &&
-        (reason == NS_ERROR_NET_RESET ||
-         reason == NS_OK ||
-         reason == NS_ERROR_NET_TIMEOUT ||
-         reason == NS_BASE_STREAM_CLOSED)) {
-        trans->Close(NS_ERROR_NET_RESET);
-    }
-    else {
-        trans->Close(reason);
-    }
-
-    mResponseQ.Clear();
-}
-
-nsresult
-nsHttpPipeline::OnReadSegment(const char *segment,
-                              uint32_t count,
-                              uint32_t *countRead)
-{
-    return mSendBufOut->Write(segment, count, countRead);
-}
-
-nsresult
-nsHttpPipeline::FillSendBuf()
-{
-    // reads from request queue, moving transactions to response queue
-    // when they have been completely read.
-
-    nsresult rv;
-
-    if (!mSendBufIn) {
-        // allocate a single-segment pipe
-        rv = NS_NewPipe(getter_AddRefs(mSendBufIn),
-                        getter_AddRefs(mSendBufOut),
-                        nsIOService::gDefaultSegmentSize,  /* segment size */
-                        nsIOService::gDefaultSegmentSize,  /* max size */
-                        true, true);
-        if (NS_FAILED(rv)) return rv;
-    }
-
-    uint32_t n;
-    uint64_t avail;
-    RefPtr<nsAHttpTransaction> trans;
-    nsITransport *transport = Transport();
-
-    while ((trans = Request(0)) != nullptr) {
-        avail = trans->Available();
-        if (avail) {
-            // if there is already a response in the responseq then this
-            // new data comprises a pipeline. Update the transaction in the
-            // response queue to reflect that if necessary. We are now sending
-            // out a request while we haven't received all responses.
-            nsAHttpTransaction *response = Response(0);
-            if (response && !response->PipelinePosition())
-                response->SetPipelinePosition(1);
-            rv = trans->ReadSegments(this, (uint32_t)std::min(avail, (uint64_t)UINT32_MAX), &n);
-            if (NS_FAILED(rv)) return rv;
-
-            if (n == 0) {
-                LOG(("send pipe is full"));
-                break;
-            }
-
-            mSendingToProgress += n;
-            if (!mSuppressSendEvents && transport) {
-                // Simulate a SENDING_TO event
-                trans->OnTransportStatus(transport,
-                                         NS_NET_STATUS_SENDING_TO,
-                                         mSendingToProgress);
-            }
-        }
-
-        avail = trans->Available();
-        if (avail == 0) {
-            // move transaction from request queue to response queue
-            mRequestQ.RemoveElementAt(0);
-            mResponseQ.AppendElement(trans);
-            mRequestIsPartial = false;
-
-            if (!mSuppressSendEvents && transport) {
-                // Simulate a WAITING_FOR event
-                trans->OnTransportStatus(transport,
-                                         NS_NET_STATUS_WAITING_FOR,
-                                         mSendingToProgress);
-            }
-
-            // It would be good to re-enable data read handlers via ResumeRecv()
-            // except the read handler code can be synchronously dispatched on
-            // the stack.
-        }
-        else
-            mRequestIsPartial = true;
-    }
-    return NS_OK;
-}
-
-} // namespace net
-} // namespace mozilla
deleted file mode 100644
--- a/netwerk/protocol/http/nsHttpPipeline.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef nsHttpPipeline_h__
-#define nsHttpPipeline_h__
-
-#include "nsAHttpConnection.h"
-#include "nsAHttpTransaction.h"
-#include "nsTArray.h"
-#include "nsCOMPtr.h"
-
-class nsIInputStream;
-class nsIOutputStream;
-
-namespace mozilla { namespace net {
-
-class nsHttpPipeline final : public nsAHttpConnection
-                           , public nsAHttpTransaction
-                           , public nsAHttpSegmentReader
-{
-public:
-    NS_DECL_THREADSAFE_ISUPPORTS
-    NS_DECL_NSAHTTPCONNECTION(mConnection)
-    NS_DECL_NSAHTTPTRANSACTION
-    NS_DECL_NSAHTTPSEGMENTREADER
-
-    nsHttpPipeline();
-
-  bool ResponseTimeoutEnabled() const override final {
-    return true;
-  }
-
-private:
-    virtual ~nsHttpPipeline();
-
-    nsresult FillSendBuf();
-
-    static nsresult ReadFromPipe(nsIInputStream *, void *, const char *,
-                                 uint32_t, uint32_t, uint32_t *);
-
-    // convenience functions
-    nsAHttpTransaction *Request(int32_t i)
-    {
-        if (mRequestQ.Length() == 0)
-            return nullptr;
-
-        return mRequestQ[i];
-    }
-    nsAHttpTransaction *Response(int32_t i)
-    {
-        if (mResponseQ.Length() == 0)
-            return nullptr;
-
-        return mResponseQ[i];
-    }
-
-    // overload of nsAHttpTransaction::QueryPipeline()
-    nsHttpPipeline *QueryPipeline() override;
-
-    RefPtr<nsAHttpConnection>   mConnection;
-    nsTArray<RefPtr<nsAHttpTransaction> > mRequestQ;
-    nsTArray<RefPtr<nsAHttpTransaction> > mResponseQ;
-    nsresult                      mStatus;
-
-    // these flags indicate whether or not the first request or response
-    // is partial.  a partial request means that Request(0) has been
-    // partially written out to the socket.  a partial response means
-    // that Response(0) has been partially read in from the socket.
-    bool mRequestIsPartial;
-    bool mResponseIsPartial;
-
-    // indicates whether or not the pipeline has been explicitly closed.
-    bool mClosed;
-
-    // indicates whether or not a true pipeline (more than 1 request without
-    // a synchronous response) has been formed.
-    bool mUtilizedPipeline;
-
-    // used when calling ReadSegments/WriteSegments on a transaction.
-    nsAHttpSegmentReader *mReader;
-
-    // send buffer
-    nsCOMPtr<nsIInputStream>  mSendBufIn;
-    nsCOMPtr<nsIOutputStream> mSendBufOut;
-
-    // the push back buffer.  not exceeding nsIOService::gDefaultSegmentSize bytes.
-    char     *mPushBackBuf;
-    uint32_t  mPushBackLen;
-    uint32_t  mPushBackMax;
-
-    // The number of transactions completed on this pipeline.
-    uint32_t  mHttp1xTransactionCount;
-
-    // For support of OnTransportStatus()
-    int64_t  mReceivingFromProgress;
-    int64_t  mSendingToProgress;
-    bool     mSuppressSendEvents;
-};
-
-} // namespace net
-} // namespace mozilla
-
-#endif // nsHttpPipeline_h__
--- a/netwerk/protocol/http/nsHttpTransaction.cpp
+++ b/netwerk/protocol/http/nsHttpTransaction.cpp
@@ -99,18 +99,16 @@ nsHttpTransaction::nsHttpTransaction()
     , mInvalidResponseBytesRead(0)
     , mPushedStream(nullptr)
     , mInitialRwin(0)
     , mChunkedDecoder(nullptr)
     , mStatus(NS_OK)
     , mPriority(0)
     , mRestartCount(0)
     , mCaps(0)
-    , mClassification(CLASS_GENERAL)
-    , mPipelinePosition(0)
     , mHttpVersion(NS_HTTP_VERSION_UNKNOWN)
     , mHttpResponseCode(0)
     , mCurrentHttpResponseHeaderSize(0)
     , mCapsToClear(0)
     , mResponseIsComplete(false)
     , mClosed(false)
     , mConnected(false)
     , mHaveStatusLine(false)
@@ -140,17 +138,16 @@ nsHttpTransaction::nsHttpTransaction()
     , mSubmittedRatePacing(false)
     , mPassedRatePacing(false)
     , mSynchronousRatePaceRequest(false)
     , mClassOfService(0)
     , m0RTTInProgress(false)
     , mTransportStatus(NS_OK)
 {
     LOG(("Creating nsHttpTransaction @%p\n", this));
-    gHttpHandler->GetMaxPipelineObjectSize(&mMaxPipelineObjectSize);
 
 #ifdef MOZ_VALGRIND
     memset(&mSelfAddr, 0, sizeof(NetAddr));
     memset(&mPeerAddr, 0, sizeof(NetAddr));
 #endif
     mSelfAddr.raw.family = PR_AF_UNSPEC;
     mPeerAddr.raw.family = PR_AF_UNSPEC;
 }
@@ -176,55 +173,16 @@ nsHttpTransaction::~nsHttpTransaction()
     mConnection = nullptr;
 
     delete mResponseHead;
     delete mForTakeResponseHead;
     delete mChunkedDecoder;
     ReleaseBlockingTransaction();
 }
 
-nsHttpTransaction::Classifier
-nsHttpTransaction::Classify()
-{
-    if (!(mCaps & NS_HTTP_ALLOW_PIPELINING))
-        return (mClassification = CLASS_SOLO);
-
-    if (mRequestHead->HasHeader(nsHttp::If_Modified_Since) ||
-        mRequestHead->HasHeader(nsHttp::If_None_Match))
-        return (mClassification = CLASS_REVALIDATION);
-
-    nsAutoCString accept;
-    bool hasAccept = NS_SUCCEEDED(mRequestHead->GetHeader(nsHttp::Accept, accept));
-    if (hasAccept && StringBeginsWith(accept, NS_LITERAL_CSTRING("image/"))) {
-        return (mClassification = CLASS_IMAGE);
-    }
-
-    if (hasAccept && StringBeginsWith(accept, NS_LITERAL_CSTRING("text/css"))) {
-        return (mClassification = CLASS_SCRIPT);
-    }
-
-    mClassification = CLASS_GENERAL;
-
-    nsAutoCString requestURI;
-    mRequestHead->RequestURI(requestURI);
-    int32_t queryPos = requestURI.FindChar('?');
-    if (queryPos == kNotFound) {
-        if (StringEndsWith(requestURI,
-                           NS_LITERAL_CSTRING(".js")))
-            mClassification = CLASS_SCRIPT;
-    }
-    else if (queryPos >= 3 &&
-             Substring(requestURI, queryPos - 3, 3).
-             EqualsLiteral(".js")) {
-        mClassification = CLASS_SCRIPT;
-    }
-
-    return mClassification;
-}
-
 nsresult
 nsHttpTransaction::Init(uint32_t caps,
                         nsHttpConnectionInfo *cinfo,
                         nsHttpRequestHead *requestHead,
                         nsIInputStream *requestBody,
                         bool requestBodyHasHeaders,
                         nsIEventTarget *target,
                         nsIInterfaceRequestor *callbacks,
@@ -410,18 +368,16 @@ nsHttpTransaction::Init(uint32_t caps,
     if (NS_FAILED(rv)) return rv;
 
 #ifdef WIN32 // bug 1153929
     MOZ_DIAGNOSTIC_ASSERT(mPipeOut);
     uint32_t * vtable = (uint32_t *) mPipeOut.get();
     MOZ_DIAGNOSTIC_ASSERT(*vtable != 0);
 #endif // WIN32
 
-    Classify();
-
     nsCOMPtr<nsIAsyncInputStream> tmp(mPipeIn);
     tmp.forget(responseBody);
     return NS_OK;
 }
 
 // This method should only be used on the socket thread
 nsAHttpConnection *
 nsHttpTransaction::Connection()
@@ -438,17 +394,17 @@ nsHttpTransaction::GetConnectionReferenc
     return connection.forget();
 }
 
 nsHttpResponseHead *
 nsHttpTransaction::TakeResponseHead()
 {
     MOZ_ASSERT(!mResponseHeadTaken, "TakeResponseHead called 2x");
 
-    // Lock RestartInProgress() and TakeResponseHead() against main thread
+    // Lock TakeResponseHead() against main thread
     MutexAutoLock lock(*nsHttp::GetLock());
 
     mResponseHeadTaken = true;
 
     // Prefer mForTakeResponseHead over mResponseHead. It is always a complete
     // set of headers.
     nsHttpResponseHead *head;
     if (mForTakeResponseHead) {
@@ -623,26 +579,25 @@ nsHttpTransaction::OnTransportStatus(nsI
             (status == NS_NET_STATUS_WAITING_FOR))
             mActivityDistributor->ObserveActivity(
                 mChannel,
                 NS_HTTP_ACTIVITY_TYPE_HTTP_TRANSACTION,
                 NS_HTTP_ACTIVITY_SUBTYPE_REQUEST_BODY_SENT,
                 PR_Now(), 0, EmptyCString());
 
         // report the status and progress
-        if (!mRestartInProgressVerifier.IsDiscardingContent())
-            mActivityDistributor->ObserveActivity(
-                mChannel,
-                NS_HTTP_ACTIVITY_TYPE_SOCKET_TRANSPORT,
-                static_cast<uint32_t>(status),
-                PR_Now(),
-                progress,
-                EmptyCString());
+        mActivityDistributor->ObserveActivity(
+            mChannel,
+            NS_HTTP_ACTIVITY_TYPE_SOCKET_TRANSPORT,
+            static_cast<uint32_t>(status),
+            PR_Now(),
+            progress,
+            EmptyCString());
     }
-
+    
     // nsHttpChannel synthesizes progress events in OnDataAvailable
     if (status == NS_NET_STATUS_RECEIVING_FROM)
         return;
 
     int64_t progressMax;
 
     if (status == NS_NET_STATUS_SENDING_TO) {
         // suppress progress when only writing request headers
@@ -1026,34 +981,19 @@ nsHttpTransaction::Close(nsresult reason
 
         if (reason == psm::GetXPCOMFromNSSError(SSL_ERROR_DOWNGRADE_WITH_EARLY_DATA) ||
             (!mReceivedData &&
             ((mRequestHead && mRequestHead->IsSafeMethod()) ||
              !reallySentData || connReused))) {
             // if restarting fails, then we must proceed to close the pipe,
             // which will notify the channel that the transaction failed.
 
-            if (mPipelinePosition) {
-                gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-                    mConnInfo, nsHttpConnectionMgr::RedCanceledPipeline,
-                    nullptr, 0);
-            }
             if (NS_SUCCEEDED(Restart()))
                 return;
         }
-        else if (!mResponseIsComplete && mPipelinePosition &&
-                 reason == NS_ERROR_NET_RESET) {
-            // due to unhandled rst on a pipeline - safe to
-            // restart as only idempotent is found there
-
-            gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-                mConnInfo, nsHttpConnectionMgr::RedCorruptedContent, nullptr, 0);
-            if (NS_SUCCEEDED(RestartInProgress()))
-                return;
-        }
     }
 
     if ((mChunkedDecoder || (mContentLength >= int64_t(0))) &&
         (NS_SUCCEEDED(reason) && !mResponseIsComplete)) {
 
         NS_WARNING("Partial transfer, incomplete HTTP response received");
 
         if ((mHttpResponseCode / 100 == 2) &&
@@ -1074,30 +1014,16 @@ nsHttpTransaction::Close(nsresult reason
             // whether or not we generate an error for the transaction
             // bad framing means we don't want a pconn
             mConnection->DontReuse();
         }
     }
 
     bool relConn = true;
     if (NS_SUCCEEDED(reason)) {
-        if (!mResponseIsComplete) {
-            // The response has not been delimited with a high-confidence
-            // algorithm like Content-Length or Chunked Encoding. We
-            // need to use a strong framing mechanism to pipeline.
-            gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-                mConnInfo, nsHttpConnectionMgr::BadInsufficientFraming,
-                nullptr, mClassification);
-        }
-        else if (mPipelinePosition) {
-            // report this success as feedback
-            gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-                mConnInfo, nsHttpConnectionMgr::GoodCompletedOK,
-                nullptr, mPipelinePosition);
-        }
 
         // the server has not sent the final \r\n terminating the header
         // section, and there may still be a header line unparsed.  let's make
         // sure we parse the remaining header line, and then hopefully, the
         // response will be usable (see bug 88792).
         if (!mHaveAllHeaders) {
             char data = '\n';
             uint32_t unused;
@@ -1156,41 +1082,16 @@ nsHttpTransaction::Close(nsresult reason
 }
 
 nsHttpConnectionInfo *
 nsHttpTransaction::ConnectionInfo()
 {
     return mConnInfo.get();
 }
 
-nsresult
-nsHttpTransaction::AddTransaction(nsAHttpTransaction *trans)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-uint32_t
-nsHttpTransaction::PipelineDepth()
-{
-    return IsDone() ? 0 : 1;
-}
-
-nsresult
-nsHttpTransaction::SetPipelinePosition(int32_t position)
-{
-    mPipelinePosition = position;
-    return NS_OK;
-}
-
-int32_t
-nsHttpTransaction::PipelinePosition()
-{
-    return mPipelinePosition;
-}
-
 bool // NOTE BASE CLASS
 nsAHttpTransaction::ResponseTimeoutEnabled() const
 {
     return false;
 }
 
 PRIntervalTime // NOTE BASE CLASS
 nsAHttpTransaction::ResponseTimeout()
@@ -1204,81 +1105,16 @@ nsHttpTransaction::ResponseTimeoutEnable
     return mResponseTimeoutEnabled;
 }
 
 //-----------------------------------------------------------------------------
 // nsHttpTransaction <private>
 //-----------------------------------------------------------------------------
 
 nsresult
-nsHttpTransaction::RestartInProgress()
-{
-    MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-
-    if ((mRestartCount + 1) >= gHttpHandler->MaxRequestAttempts()) {
-        LOG(("nsHttpTransaction::RestartInProgress() "
-             "reached max request attempts, failing transaction %p\n", this));
-        return NS_ERROR_NET_RESET;
-    }
-
-    // Lock RestartInProgress() and TakeResponseHead() against main thread
-    MutexAutoLock lock(*nsHttp::GetLock());
-
-    // Don't try and RestartInProgress() things that haven't gotten a response
-    // header yet. Those should be handled under the normal restart() path if
-    // they are eligible.
-    if (!mHaveAllHeaders)
-        return NS_ERROR_NET_RESET;
-
-    if (mCaps & NS_HTTP_STICKY_CONNECTION) {
-        return NS_ERROR_NET_RESET;
-    }
-
-    // don't try and restart 0.9 or non 200/Get HTTP/1
-    if (!mRestartInProgressVerifier.IsSetup())
-        return NS_ERROR_NET_RESET;
-
-    LOG(("Will restart transaction %p and skip first %" PRId64 " bytes, "
-         "old Content-Length %" PRId64,
-         this, mContentRead, mContentLength));
-
-    mRestartInProgressVerifier.SetAlreadyProcessed(
-        std::max(mRestartInProgressVerifier.AlreadyProcessed(), mContentRead));
-
-    if (!mResponseHeadTaken && !mForTakeResponseHead) {
-        // TakeResponseHeader() has not been called yet and this
-        // is the first restart. Store the resp headers exclusively
-        // for TakeResponseHead() which is called from the main thread and
-        // could happen at any time - so we can't continue to modify those
-        // headers (which restarting will effectively do)
-        mForTakeResponseHead = mResponseHead;
-        mResponseHead = nullptr;
-    }
-
-    if (mResponseHead) {
-        mResponseHead->Reset();
-    }
-
-    mContentRead = 0;
-    mContentLength = -1;
-    delete mChunkedDecoder;
-    mChunkedDecoder = nullptr;
-    mHaveStatusLine = false;
-    mHaveAllHeaders = false;
-    mHttpResponseMatched = false;
-    mResponseIsComplete = false;
-    mDidContentStart = false;
-    mNoContent = false;
-    mSentData = false;
-    mReceivedData = false;
-
-    return Restart();
-}
-
-nsresult
 nsHttpTransaction::Restart()
 {
     MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
 
     // limit the number of restart attempts - bug 92224
     if (++mRestartCount >= gHttpHandler->MaxRequestAttempts()) {
         LOG(("reached max request attempts, failing transaction @%p\n", this));
         return NS_ERROR_NET_RESET;
@@ -1301,22 +1137,16 @@ nsHttpTransaction::Restart()
         MutexAutoLock lock(mLock);
         mConnection = nullptr;
     }
 
     // Reset this to our default state, since this may change from one restart
     // to the next
     mReuseOnRestart = false;
 
-    // disable pipelining for the next attempt in case pipelining caused the
-    // reset.  this is being overly cautious since we don't know if pipelining
-    // was the problem here.
-    mCaps &= ~NS_HTTP_ALLOW_PIPELINING;
-    SetPipelinePosition(0);
-
     if (!mConnInfo->GetRoutedHost().IsEmpty()) {
         MutexAutoLock lock(*nsHttp::GetLock());
         RefPtr<nsHttpConnectionInfo> ci;
          mConnInfo->CloneAsDirectRoute(getter_AddRefs(ci));
          mConnInfo = ci;
         if (mRequestHead) {
             mRequestHead->SetHeader(nsHttp::Alternate_Service_Used, NS_LITERAL_CSTRING("0"));
         }
@@ -1436,19 +1266,16 @@ nsHttpTransaction::ParseLineSegment(char
         // not a continuation of the previous or if we haven't
         // parsed the status line yet, then parse the contents
         // of mLineBuf.
         mLineBuf.Truncate(mLineBuf.Length() - 1);
         if (!mHaveStatusLine || (*segment != ' ' && *segment != '\t')) {
             nsresult rv = ParseLine(mLineBuf);
             mLineBuf.Truncate();
             if (NS_FAILED(rv)) {
-                gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-                    mConnInfo, nsHttpConnectionMgr::RedCorruptedContent,
-                    nullptr, 0);
                 return rv;
             }
         }
     }
 
     // append segment to mLineBuf...
     mLineBuf.Append(segment, len);
 
@@ -1617,18 +1444,17 @@ nsHttpTransaction::HandleContentStart()
 
         // Save http version, mResponseHead isn't available anymore after
         // TakeResponseHead() is called
         mHttpVersion = mResponseHead->Version();
         mHttpResponseCode = mResponseHead->Status();
 
         // notify the connection, give it a chance to cause a reset.
         bool reset = false;
-        if (!mRestartInProgressVerifier.IsSetup())
-            mConnection->OnHeadersAvailable(this, mRequestHead, mResponseHead, &reset);
+        mConnection->OnHeadersAvailable(this, mRequestHead, mResponseHead, &reset);
 
         // looks like we should ignore this response, resetting...
         if (reset) {
             LOG(("resetting transaction's response head\n"));
             mHaveAllHeaders = false;
             mHaveStatusLine = false;
             mReceivedData = false;
             mSentData = false;
@@ -1663,31 +1489,23 @@ nsHttpTransaction::HandleContentStart()
         }
 
         if (mResponseHead->Status() == 200 &&
             mConnection->IsProxyConnectInProgress()) {
             // successful CONNECTs do not have response bodies
             mNoContent = true;
         }
         mConnection->SetLastTransactionExpectedNoContent(mNoContent);
-        if (mInvalidResponseBytesRead)
-            gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-                mConnInfo, nsHttpConnectionMgr::BadInsufficientFraming,
-                nullptr, mClassification);
 
-        if (mNoContent)
+        if (mNoContent) {
             mContentLength = 0;
-        else {
+        } else {
             // grab the content-length from the response headers
             mContentLength = mResponseHead->ContentLength();
 
-            if ((mClassification != CLASS_SOLO) &&
-                (mContentLength > mMaxPipelineObjectSize))
-                CancelPipeline(nsHttpConnectionMgr::BadUnexpectedLarge);
-
             // handle chunked encoding here, so we'll know immediately when
             // we're done with the socket.  please note that _all_ other
             // decoding is done when the channel receives the content data
             // so as not to block the socket transport thread too much.
             if (mResponseHead->Version() >= NS_HTTP_VERSION_1_0 &&
                 mResponseHead->HasHeaderValue(nsHttp::Transfer_Encoding, "chunked")) {
                 // we only support the "chunked" transfer encoding right now.
                 mChunkedDecoder = new nsHttpChunkedDecoder();
@@ -1699,30 +1517,19 @@ nsHttpTransaction::HandleContentStart()
                     if (mConnection) {
                         mConnection->DontReuse();
                     }
                 }
             }
             else if (mContentLength == int64_t(-1))
                 LOG(("waiting for the server to close the connection.\n"));
         }
-        if (mRestartInProgressVerifier.IsSetup() &&
-            !mRestartInProgressVerifier.Verify(mContentLength, mResponseHead)) {
-            LOG(("Restart in progress subsequent transaction failed to match"));
-            return NS_ERROR_ABORT;
-        }
     }
 
     mDidContentStart = true;
-
-    // The verifier only initializes itself once (from the first iteration of
-    // a transaction that gets far enough to have response headers)
-    if (mRequestHead->IsGet())
-        mRestartInProgressVerifier.Set(mContentLength, mResponseHead);
-
     return NS_OK;
 }
 
 // called on the socket thread
 nsresult
 nsHttpTransaction::HandleContent(char *buf,
                                  uint32_t count,
                                  uint32_t *contentRead,
@@ -1773,48 +1580,24 @@ nsHttpTransaction::HandleContent(char *b
         }
     }
     else {
         // when we are just waiting for the server to close the connection...
         // (no explicit content-length given)
         *contentRead = count;
     }
 
-    int64_t toReadBeforeRestart =
-        mRestartInProgressVerifier.ToReadBeforeRestart();
-
-    if (toReadBeforeRestart && *contentRead) {
-        uint32_t ignore =
-            static_cast<uint32_t>(std::min<int64_t>(toReadBeforeRestart, UINT32_MAX));
-        ignore = std::min(*contentRead, ignore);
-        LOG(("Due To Restart ignoring %d of remaining %" PRId64,
-             ignore, toReadBeforeRestart));
-        *contentRead -= ignore;
-        mContentRead += ignore;
-        mRestartInProgressVerifier.HaveReadBeforeRestart(ignore);
-        memmove(buf, buf + ignore, *contentRead + *contentRemaining);
-    }
-
     if (*contentRead) {
         // update count of content bytes read and report progress...
         mContentRead += *contentRead;
     }
 
     LOG(("nsHttpTransaction::HandleContent [this=%p count=%u read=%u mContentRead=%" PRId64 " mContentLength=%" PRId64 "]\n",
         this, count, *contentRead, mContentRead, mContentLength));
 
-    // Check the size of chunked responses. If we exceed the max pipeline size
-    // for this response reschedule the pipeline
-    if ((mClassification != CLASS_SOLO) &&
-        mChunkedDecoder &&
-        ((mContentRead + mChunkedDecoder->GetChunkRemaining()) >
-         mMaxPipelineObjectSize)) {
-        CancelPipeline(nsHttpConnectionMgr::BadUnexpectedLarge);
-    }
-
     // check for end-of-file
     if ((mContentRead == mContentLength) ||
         (mChunkedDecoder && mChunkedDecoder->ReachedEOF())) {
         // the transaction is done with a complete response.
         mTransactionDone = true;
         mResponseIsComplete = true;
         ReleaseBlockingTransaction();
 
@@ -1897,17 +1680,17 @@ nsHttpTransaction::ProcessData(char *buf
         // buf layout:
         //
         // +--------------------------------------+----------------+-----+
         // |              countRead               | countRemaining |     |
         // +--------------------------------------+----------------+-----+
         //
         // count          : bytes read from the socket
         // countRead      : bytes corresponding to this transaction
-        // countRemaining : bytes corresponding to next pipelined transaction
+        // countRemaining : bytes corresponding to next transaction on conn
         //
         // NOTE:
         // count > countRead + countRemaining <==> chunked transfer encoding
         //
         rv = HandleContent(buf, count, countRead, &countRemaining);
         if (NS_FAILED(rv)) return rv;
         // we may have read more than our share, in which case we must give
         // the excess bytes back to the connection
@@ -1922,43 +1705,25 @@ nsHttpTransaction::ProcessData(char *buf
             mContentDecodingCheck = true;
         }
     }
 
     return NS_OK;
 }
 
 void
-nsHttpTransaction::CancelPipeline(uint32_t reason)
-{
-    // reason is casted through a uint to avoid compiler header deps
-    gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-        mConnInfo,
-        static_cast<nsHttpConnectionMgr::PipelineFeedbackInfoType>(reason),
-        nullptr, mClassification);
-
-    mConnection->CancelPipeline(NS_ERROR_ABORT);
-
-    // Avoid pipelining this transaction on restart by classifying it as solo.
-    // This also prevents BadUnexpectedLarge from being reported more
-    // than one time per transaction.
-    mClassification = CLASS_SOLO;
-}
-
-
-void
 nsHttpTransaction::SetRequestContext(nsIRequestContext *aRequestContext)
 {
     LOG(("nsHttpTransaction %p SetRequestContext %p\n", this, aRequestContext));
     mRequestContext = aRequestContext;
 }
 
 // Called when the transaction marked for blocking is associated with a connection
-// (i.e. added to a new h1 conn, an idle http connection, or placed into
-// a http pipeline). It is safe to call this multiple times with it only
+// (i.e. added to a new h1 conn, an idle http connection, etc..)
+// It is safe to call this multiple times with it only
 // having an effect once.
 void
 nsHttpTransaction::DispatchedAsBlocking()
 {
     if (mDispatchedAsBlocking)
         return;
 
     LOG(("nsHttpTransaction %p dispatched as blocking\n", this));
@@ -2324,105 +2089,16 @@ nsHttpTransaction::OnOutputStreamReady(n
         mConnection->TransactionHasDataToRecv(this);
         nsresult rv = mConnection->ResumeRecv();
         if (NS_FAILED(rv))
             NS_ERROR("ResumeRecv failed");
     }
     return NS_OK;
 }
 
-// nsHttpTransaction::RestartVerifier
-
-static bool
-matchOld(nsHttpResponseHead *newHead, nsCString &old,
-         nsHttpAtom headerAtom)
-{
-    nsAutoCString val;
-
-    newHead->GetHeader(headerAtom, val);
-    if (!val.IsEmpty() && old.IsEmpty())
-        return false;
-    if (val.IsEmpty() && !old.IsEmpty())
-        return false;
-    if (!val.IsEmpty() && !old.Equals(val))
-        return false;
-    return true;
-}
-
-bool
-nsHttpTransaction::RestartVerifier::Verify(int64_t contentLength,
-                                           nsHttpResponseHead *newHead)
-{
-    if (mContentLength != contentLength)
-        return false;
-
-    if (newHead->Status() != 200)
-        return false;
-
-    if (!matchOld(newHead, mContentRange, nsHttp::Content_Range))
-        return false;
-
-    if (!matchOld(newHead, mLastModified, nsHttp::Last_Modified))
-        return false;
-
-    if (!matchOld(newHead, mETag, nsHttp::ETag))
-        return false;
-
-    if (!matchOld(newHead, mContentEncoding, nsHttp::Content_Encoding))
-        return false;
-
-    if (!matchOld(newHead, mTransferEncoding, nsHttp::Transfer_Encoding))
-        return false;
-
-    return true;
-}
-
-void
-nsHttpTransaction::RestartVerifier::Set(int64_t contentLength,
-                                        nsHttpResponseHead *head)
-{
-    if (mSetup)
-        return;
-
-    // If mSetup does not transition to true RestartInPogress() is later
-    // forbidden
-
-    // Only RestartInProgress with 200 response code
-    if (!head || (head->Status() != 200)) {
-        return;
-    }
-
-    mContentLength = contentLength;
-
-    nsAutoCString val;
-    if (NS_SUCCEEDED(head->GetHeader(nsHttp::ETag, val))) {
-        mETag = val;
-    }
-    if (NS_SUCCEEDED(head->GetHeader(nsHttp::Last_Modified, val))) {
-        mLastModified = val;
-    }
-    if (NS_SUCCEEDED(head->GetHeader(nsHttp::Content_Range, val))) {
-        mContentRange = val;
-    }
-    if (NS_SUCCEEDED(head->GetHeader(nsHttp::Content_Encoding, val))) {
-        mContentEncoding = val;
-    }
-    if (NS_SUCCEEDED(head->GetHeader(nsHttp::Transfer_Encoding, val))) {
-        mTransferEncoding = val;
-    }
-
-    // We can only restart with any confidence if we have a stored etag or
-    // last-modified header
-    if (mETag.IsEmpty() && mLastModified.IsEmpty()) {
-        return;
-    }
-
-    mSetup = true;
-}
-
 void
 nsHttpTransaction::GetNetworkAddresses(NetAddr &self, NetAddr &peer)
 {
     MutexAutoLock lock(mLock);
     self = mSelfAddr;
     peer = mPeerAddr;
 }
 
--- a/netwerk/protocol/http/nsHttpTransaction.h
+++ b/netwerk/protocol/http/nsHttpTransaction.h
@@ -114,24 +114,21 @@ public:
 
     void EnableKeepAlive() { mCaps |= NS_HTTP_ALLOW_KEEPALIVE; }
     void MakeSticky() { mCaps |= NS_HTTP_STICKY_CONNECTION; }
 
     // SetPriority() may only be used by the connection manager.
     void    SetPriority(int32_t priority) { mPriority = priority; }
     int32_t    Priority()                 { return mPriority; }
 
-    enum Classifier Classification() { return mClassification; }
-
     void PrintDiagnostics(nsCString &log);
 
     // Sets mPendingTime to the current time stamp or to a null time stamp (if now is false)
     void SetPendingTime(bool now = true) { mPendingTime = now ? TimeStamp::Now() : TimeStamp(); }
     const TimeStamp GetPendingTime() { return mPendingTime; }
-    bool UsesPipelining() const { return mCaps & NS_HTTP_ALLOW_PIPELINING; }
 
     // overload of nsAHttpTransaction::RequestContext()
     nsIRequestContext *RequestContext() override { return mRequestContext.get(); }
     void SetRequestContext(nsIRequestContext *aRequestContext);
     void DispatchedAsBlocking();
     void RemoveDispatchedAsBlocking();
 
     nsHttpTransaction *QueryHttpTransaction() override { return this; }
@@ -169,31 +166,27 @@ public:
 
     bool Do0RTT() override;
     nsresult Finish0RTT(bool aRestart, bool aAlpnChanged /* ignored */) override;
 private:
     friend class DeleteHttpTransaction;
     virtual ~nsHttpTransaction();
 
     nsresult Restart();
-    nsresult RestartInProgress();
     char    *LocateHttpStart(char *buf, uint32_t len,
                              bool aAllowPartialMatch);
     nsresult ParseLine(nsACString &line);
     nsresult ParseLineSegment(char *seg, uint32_t len);
     nsresult ParseHead(char *, uint32_t count, uint32_t *countRead);
     nsresult HandleContentStart();
     nsresult HandleContent(char *, uint32_t count, uint32_t *contentRead, uint32_t *contentRemaining);
     nsresult ProcessData(char *, uint32_t, uint32_t *);
     void     DeleteSelfOnConsumerThread();
     void     ReleaseBlockingTransaction();
 
-    Classifier Classify();
-    void       CancelPipeline(uint32_t reason);
-
     static nsresult ReadRequestSegment(nsIInputStream *, void *, const char *,
                                        uint32_t, uint32_t, uint32_t *);
     static nsresult WritePipeSegment(nsIOutputStream *, void *, char *,
                                      uint32_t, uint32_t, uint32_t *);
 
     bool TimingEnabled() const { return mCaps & NS_HTTP_TIMING_ENABLED; }
 
     bool ResponseTimeoutEnabled() const final;
@@ -274,19 +267,16 @@ private:
     TimingStruct                    mTimings;
 
     nsresult                        mStatus;
 
     int16_t                         mPriority;
 
     uint16_t                        mRestartCount;        // the number of times this transaction has been restarted
     uint32_t                        mCaps;
-    enum Classifier                 mClassification;
-    int32_t                         mPipelinePosition;
-    int64_t                         mMaxPipelineObjectSize;
 
     nsHttpVersion                   mHttpVersion;
     uint16_t                        mHttpResponseCode;
 
     uint32_t                        mCurrentHttpResponseHeaderSize;
 
     // mCapsToClear holds flags that should be cleared in mCaps, e.g. unset
     // NS_HTTP_REFRESH_DNS when DNS refresh request has completed to avoid
@@ -333,78 +323,16 @@ private:
 
     // protected by nsHttp::GetLock()
     nsHttpResponseHead             *mForTakeResponseHead;
     bool                            mResponseHeadTaken;
 
     // The time when the transaction was submitted to the Connection Manager
     TimeStamp                       mPendingTime;
 
-    class RestartVerifier
-    {
-
-        // When a idemptotent transaction has received part of its response body
-        // and incurs an error it can be restarted. To do this we mark the place
-        // where we stopped feeding the body to the consumer and start the
-        // network call over again. If everything we track (headers, length, etc..)
-        // matches up to the place where we left off then the consumer starts being
-        // fed data again with the new information. This can be done N times up
-        // to the normal restart (i.e. with no response info) limit.
-
-    public:
-        RestartVerifier()
-            : mContentLength(-1)
-            , mAlreadyProcessed(0)
-            , mToReadBeforeRestart(0)
-            , mSetup(false)
-        {}
-        ~RestartVerifier() {}
-
-        void Set(int64_t contentLength, nsHttpResponseHead *head);
-        bool Verify(int64_t contentLength, nsHttpResponseHead *head);
-        bool IsDiscardingContent() { return mToReadBeforeRestart != 0; }
-        bool IsSetup() { return mSetup; }
-        int64_t AlreadyProcessed() { return mAlreadyProcessed; }
-        void SetAlreadyProcessed(int64_t val) {
-            mAlreadyProcessed = val;
-            mToReadBeforeRestart = val;
-        }
-        int64_t ToReadBeforeRestart() { return mToReadBeforeRestart; }
-        void HaveReadBeforeRestart(uint32_t amt)
-        {
-            MOZ_ASSERT(amt <= mToReadBeforeRestart,
-                       "too large of a HaveReadBeforeRestart deduction");
-            mToReadBeforeRestart -= amt;
-        }
-
-    private:
-        // This is the data from the first complete response header
-        // used to make sure that all subsequent response headers match
-
-        int64_t                         mContentLength;
-        nsCString                       mETag;
-        nsCString                       mLastModified;
-        nsCString                       mContentRange;
-        nsCString                       mContentEncoding;
-        nsCString                       mTransferEncoding;
-
-        // This is the amount of data that has been passed to the channel
-        // from previous iterations of the transaction and must therefore
-        // be skipped in the new one.
-        int64_t                         mAlreadyProcessed;
-
-        // The amount of data that must be discarded in the current iteration
-        // (where iteration > 0) to reach the mAlreadyProcessed high water
-        // mark.
-        int64_t                         mToReadBeforeRestart;
-
-        // true when ::Set has been called with a response header
-        bool                            mSetup;
-    } mRestartInProgressVerifier;
-
 // For Rate Pacing via an EventTokenBucket
 public:
     // called by the connection manager to run this transaction through the
     // token bucket. If the token bucket admits the transaction immediately it
     // returns true. The function is called repeatedly until it returns true.
     bool TryToRunPacedRequest();
 
     // ATokenBucketEvent pure virtual implementation. Called by the token bucket
--- a/netwerk/protocol/http/nsIHttpChannel.idl
+++ b/netwerk/protocol/http/nsIHttpChannel.idl
@@ -201,26 +201,17 @@ interface nsIHttpChannel : nsIChannel
      * behavior. Don't do it!
      *
      * @param aVisitor
      *        the header visitor instance.
      */
     void visitNonDefaultRequestHeaders(in nsIHttpHeaderVisitor aVisitor);
 
     /**
-     * This attribute is a hint to the channel to indicate whether or not
-     * the underlying HTTP transaction should be allowed to be pipelined
-     * with other transactions.  This should be set to FALSE, for example,
-     * if the application knows that the corresponding document is likely
-     * to be very large.
-     *
-     * This attribute is true by default, though other factors may prevent
-     * pipelining.
-     *
-     * This attribute may only be set before the channel is opened.
+     * This attribute no longer has any effect, it remains for backwards compat
      *
      * @throws NS_ERROR_FAILURE if set after the channel has been opened.
      */
     attribute boolean allowPipelining;
 
     /**
      * This attribute of the channel indicates whether or not
      * the underlying HTTP transaction should be honor stored Strict Transport
deleted file mode 100644
--- a/netwerk/test/unit/test_assoc.js
+++ /dev/null
@@ -1,102 +0,0 @@
-Cu.import("resource://testing-common/httpd.js");
-Cu.import("resource://gre/modules/NetUtil.jsm");
-
-var httpserver = new HttpServer();
-var currentTestIndex = 0;
-
-XPCOMUtils.defineLazyGetter(this, "port", function() {
-    return httpserver.identity.primaryPort;
-});
-
-XPCOMUtils.defineLazyGetter(this, "tests", function() {
-    return [
-            // this is valid
-            {url: "/assoc/assoctest?valid",
-             responseheader: ["Assoc-Req: GET http://localhost:" + port +
-                              "/assoc/assoctest?valid",
-                              "Pragma: X-Verify-Assoc-Req"],
-             flags: 0},
-
-            // this is invalid because the method is wrong
-            {url: "/assoc/assoctest?invalid",
-             responseheader: ["Assoc-Req: POST http://localhost:" + port +
-                              "/assoc/assoctest?invalid",
-                              "Pragma: X-Verify-Assoc-Req"],
-             flags: CL_EXPECT_LATE_FAILURE},
-
-            // this is invalid because the url is wrong
-            {url: "/assoc/assoctest?notvalid",
-             responseheader: ["Assoc-Req: GET http://localhost:" + port +
-                              "/wrongpath/assoc/assoctest?notvalid",
-                              "Pragma: X-Verify-Assoc-Req"],
-             flags: CL_EXPECT_LATE_FAILURE},
-
-             // this is invalid because the space between method and URL is missing
-            {url: "/assoc/assoctest?invalid2",
-             responseheader: ["Assoc-Req: GEThttp://localhost:" + port +
-                              "/assoc/assoctest?invalid2",
-                              "Pragma: X-Verify-Assoc-Req"],
-             flags: CL_EXPECT_LATE_FAILURE},
-    ];
-});
-
-var oldPrefVal;
-var domBranch;
-
-function setupChannel(url)
-{
-  return NetUtil.newChannel({
-    uri: "http://localhost:" + port + url,
-    loadUsingSystemPrincipal: true
-  });
-}
-
-function startIter()
-{
-    var channel = setupChannel(tests[currentTestIndex].url);
-    channel.asyncOpen2(new ChannelListener(completeIter,
-                                          channel, tests[currentTestIndex].flags));
-}
-
-function completeIter(request, data, ctx)
-{
-    if (++currentTestIndex < tests.length ) {
-        startIter();
-    } else {
-        domBranch.setBoolPref("enforce", oldPrefVal);
-        httpserver.stop(do_test_finished);
-    }
-}
-
-function run_test()
-{
-    var prefService =
-        Components.classes["@mozilla.org/preferences-service;1"]
-        .getService(Components.interfaces.nsIPrefService);
-    domBranch = prefService.getBranch("network.http.assoc-req.");
-    oldPrefVal = domBranch.getBoolPref("enforce");
-    domBranch.setBoolPref("enforce", true);
-
-    httpserver.registerPathHandler("/assoc/assoctest", handler);
-    httpserver.start(-1);
-
-    startIter();
-    do_test_pending();
-}
-
-function handler(metadata, response)
-{
-    var body = "thequickbrownfox";
-    response.setHeader("Content-Type", "text/plain", false);
-
-    var header = tests[currentTestIndex].responseheader;
-    if (header != undefined) {
-        for (var i = 0; i < header.length; i++) {
-            var splitHdr = header[i].split(": ");
-            response.setHeader(splitHdr[0], splitHdr[1], false);
-        }
-    }
-    
-    response.setStatusLine(metadata.httpVersion, 200, "OK");
-    response.bodyOutputStream.write(body, body.length);
-}
--- a/netwerk/test/unit/xpcshell.ini
+++ b/netwerk/test/unit/xpcshell.ini
@@ -85,17 +85,16 @@ skip-if = true
 [test_NetUtil.js]
 [test_URIs.js]
 # Intermittent time-outs on Android, bug 1285020
 requesttimeoutfactor = 2
 [test_URIs2.js]
 # Intermittent time-outs on Android, bug 1285020
 requesttimeoutfactor = 2
 [test_aboutblank.js]
-[test_assoc.js]
 [test_auth_jar.js]
 [test_auth_proxy.js]
 [test_authentication.js]
 [test_authpromptwrapper.js]
 [test_auth_dialog_permission.js]
 [test_backgroundfilesaver.js]
 # Runs for a long time, causing intermittent time-outs on Android, bug 995686
 requesttimeoutfactor = 2
--- a/toolkit/components/telemetry/Histograms.json
+++ b/toolkit/components/telemetry/Histograms.json
@@ -2565,23 +2565,16 @@
   },
   "TRANSACTION_WAIT_TIME_HTTP": {
     "expires_in_version": "never",
     "kind": "exponential",
     "high": 5000,
     "n_buckets": 100,
     "description": "Time from submission to dispatch of HTTP transaction (ms)"
   },
-  "TRANSACTION_WAIT_TIME_HTTP_PIPELINES": {
-    "expires_in_version": "never",
-    "kind": "exponential",
-    "high": 5000,
-    "n_buckets": 100,
-    "description": "Time from submission to dispatch of HTTP with pipelines transaction (ms)"
-  },
   "TRANSACTION_WAIT_TIME_SPDY": {
     "expires_in_version": "never",
     "kind": "exponential",
     "high": 5000,
     "n_buckets": 100,
     "description": "Time from submission to dispatch of SPDY transaction (ms)"
   },
   "HTTP_SAW_QUIC_ALT_PROTOCOL": {
--- a/toolkit/components/telemetry/histogram-whitelists.json
+++ b/toolkit/components/telemetry/histogram-whitelists.json
@@ -661,17 +661,16 @@
     "TAP_TO_LOAD_IMAGE_SIZE",
     "THUNDERBIRD_CONVERSATIONS_TIME_TO_2ND_GLODA_QUERY_MS",
     "THUNDERBIRD_GLODA_SIZE_MB",
     "THUNDERBIRD_INDEXING_RATE_MSG_PER_S",
     "TLS_ERROR_REPORT_UI",
     "TOP_LEVEL_CONTENT_DOCUMENTS_DESTROYED",
     "TOUCH_ENABLED_DEVICE",
     "TRANSACTION_WAIT_TIME_HTTP",
-    "TRANSACTION_WAIT_TIME_HTTP_PIPELINES",
     "TRANSACTION_WAIT_TIME_SPDY",
     "TRANSLATED_CHARACTERS",
     "TRANSLATED_PAGES",
     "TRANSLATED_PAGES_BY_LANGUAGE",
     "TRANSLATION_OPPORTUNITIES",
     "TRANSLATION_OPPORTUNITIES_BY_LANGUAGE",
     "VIDEO_CANPLAYTYPE_H264_CONSTRAINT_SET_FLAG",
     "VIDEO_CANPLAYTYPE_H264_LEVEL",
@@ -1582,17 +1581,16 @@
     "THUNDERBIRD_INDEXING_RATE_MSG_PER_S",
     "TLS_ERROR_REPORT_UI",
     "TOP_LEVEL_CONTENT_DOCUMENTS_DESTROYED",
     "TOTAL_CONTENT_PAGE_LOAD_TIME",
     "TOTAL_COUNT_HIGH_ERRORS",
     "TOTAL_COUNT_LOW_ERRORS",
     "TOUCH_ENABLED_DEVICE",
     "TRANSACTION_WAIT_TIME_HTTP",
-    "TRANSACTION_WAIT_TIME_HTTP_PIPELINES",
     "TRANSACTION_WAIT_TIME_SPDY",
     "TRANSLATED_CHARACTERS",
     "TRANSLATED_PAGES",
     "TRANSLATED_PAGES_BY_LANGUAGE",
     "TRANSLATION_OPPORTUNITIES",
     "TRANSLATION_OPPORTUNITIES_BY_LANGUAGE",
     "UPDATE_CANNOT_STAGE_EXTERNAL",
     "UPDATE_CANNOT_STAGE_NOTIFY",