Back out 1bbe7ea3a01e through 672cc4ee2dd9 because of mochitest-browser-chrome leaks
authorMatt Brubeck <mbrubeck@mozilla.com>
Tue, 20 Mar 2012 12:53:10 -0700
changeset 89868 577da08878cb6cd6f7d82f5b154eb9044fe21fa5
parent 89867 e367339ba6b286ebb766fb49f9cba29c1ec12925
child 89869 655a72e36a39e76938a6189b1547a0e3056d415d
push id22293
push usermlamouri@mozilla.com
push dateWed, 21 Mar 2012 10:30:54 +0000
treeherdermozilla-central@f10862ac3217 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
milestone14.0a1
backs out1bbe7ea3a01e1e76470f78d5f66b36d4e63ef20d
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Back out 1bbe7ea3a01e through 672cc4ee2dd9 because of mochitest-browser-chrome leaks
content/base/src/nsXMLHttpRequest.cpp
content/html/content/src/nsHTMLMediaElement.cpp
image/src/imgRequest.cpp
image/test/mochitest/Makefile.in
image/test/mochitest/invalid.jpg
image/test/mochitest/test_net_failedtoprocess.html
modules/libpref/src/init/all.js
netwerk/base/public/nsIRequest.idl
netwerk/protocol/http/SpdySession.cpp
netwerk/protocol/http/SpdySession.h
netwerk/protocol/http/nsAHttpConnection.h
netwerk/protocol/http/nsAHttpTransaction.h
netwerk/protocol/http/nsHttp.cpp
netwerk/protocol/http/nsHttp.h
netwerk/protocol/http/nsHttpAtomList.h
netwerk/protocol/http/nsHttpChannel.cpp
netwerk/protocol/http/nsHttpChannel.h
netwerk/protocol/http/nsHttpConnection.cpp
netwerk/protocol/http/nsHttpConnection.h
netwerk/protocol/http/nsHttpConnectionInfo.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/test/unit/head_channels.js
netwerk/test/unit/test_assoc.js
netwerk/test/unit/test_mismatch_lm.js
netwerk/test/unit/xpcshell.ini
--- a/content/base/src/nsXMLHttpRequest.cpp
+++ b/content/base/src/nsXMLHttpRequest.cpp
@@ -2774,20 +2774,16 @@ nsXMLHttpRequest::Send(nsIVariant *aBody
   nsCOMPtr<nsIStreamListener> listener = this;
   if (mState & XML_HTTP_REQUEST_MULTIPART) {
     listener = new nsMultipartProxyListener(listener);
     if (!listener) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
   }
 
-  // Blocking gets are common enough out of XHR that we should mark
-  // the channel slow by default for pipeline purposes
-  AddLoadFlags(mChannel, nsIRequest::INHIBIT_PIPELINE);
-
   if (!IsSystemXHR()) {
     // Always create a nsCORSListenerProxy here even if it's
     // a same-origin request right now, since it could be redirected.
     listener = new nsCORSListenerProxy(listener, mPrincipal, mChannel,
                                        withCredentials, true, &rv);
     NS_ENSURE_TRUE(listener, NS_ERROR_OUT_OF_MEMORY);
     NS_ENSURE_SUCCESS(rv, rv);
   }
--- a/content/html/content/src/nsHTMLMediaElement.cpp
+++ b/content/html/content/src/nsHTMLMediaElement.cpp
@@ -52,18 +52,16 @@
 #include "nsIDOMDocument.h"
 #include "nsDOMError.h"
 #include "nsNodeInfoManager.h"
 #include "nsNetUtil.h"
 #include "nsXPCOMStrings.h"
 #include "nsThreadUtils.h"
 #include "nsIThreadInternal.h"
 #include "nsContentUtils.h"
-#include "nsIRequest.h"
-
 #include "nsFrameManager.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsIXPConnect.h"
 #include "jsapi.h"
 
 #include "nsITimer.h"
 
 #include "nsEventDispatcher.h"
@@ -2847,23 +2845,16 @@ nsresult nsHTMLMediaElement::GetBuffered
   return NS_OK;
 }
 
 void nsHTMLMediaElement::SetRequestHeaders(nsIHttpChannel* aChannel)
 {
   // Send Accept header for video and audio types only (Bug 489071)
   SetAcceptHeader(aChannel);
 
-  // Media elements are likely candidates for HTTP Pipeline head of line
-  // blocking problems, so disable pipelines.
-  nsLoadFlags loadflags;
-  aChannel->GetLoadFlags(&loadflags);
-  loadflags |= nsIRequest::INHIBIT_PIPELINE;
-  aChannel->SetLoadFlags(loadflags);
-
   // Apache doesn't send Content-Length when gzip transfer encoding is used,
   // which prevents us from estimating the video length (if explicit Content-Duration
   // and a length spec in the container are not present either) and from seeking.
   // So, disable the standard "Accept-Encoding: gzip,deflate" that we usually send.
   // See bug 614760.
   aChannel->SetRequestHeader(NS_LITERAL_CSTRING("Accept-Encoding"),
                              EmptyCString(), false);
 
--- a/image/src/imgRequest.cpp
+++ b/image/src/imgRequest.cpp
@@ -680,25 +680,16 @@ NS_IMETHODIMP imgRequest::OnStopDecode(i
   mImage->GetStatusTracker().RecordStopDecode(aStatus, aStatusArg);
 
   nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mObservers);
   while (iter.HasMore()) {
     mImage->GetStatusTracker().SendStopDecode(iter.GetNext(), aStatus,
                                               aStatusArg);
   }
 
-  if (NS_FAILED(aStatus)) {
-    // Some kind of problem has happened with image decoding.
-    // Report the URI to net:failed-to-decode-uri observers.
-
-    nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
-    if (os)
-      os->NotifyObservers(mURI, "net:failed-to-process-uri", nsnull);
-  }
-
   // RasterImage and everything below it is completely correct and
   // bulletproof about its handling of decoder notifications.
   // Unfortunately, here and above we have to make some gross and
   // inappropriate use of things to get things to work without
   // completely overhauling the decoder observer interface (this will,
   // thankfully, happen in bug 505385). From imgRequest and above (for
   // the time being), OnStopDecode is just a companion to OnStopRequest
   // that signals success or failure of the _load_ (not the _decode_).
--- a/image/test/mochitest/Makefile.in
+++ b/image/test/mochitest/Makefile.in
@@ -113,18 +113,15 @@ include $(topsrcdir)/config/rules.mk
                 filter-final.svg \
                 test_svg_filter_animation.html \
                 test_xultree_animation.xhtml \
                 test_changeOfSource.html \
                 test_changeOfSource2.html \
                 test_undisplayed_iframe.html \
                 iframe.html \
                 ref-iframe.html \
-                test_net_failedtoprocess.html \
-                invalid.jpg \
-                damon.jpg \
                 $(NULL)
 
 libs:: $(_TEST_FILES)
 	$(INSTALL) $(foreach f,$^,"$f") $(DEPTH)/_tests/testing/mochitest/tests/$(relativesrcdir)
 
 libs:: $(_CHROME_FILES)
 	$(INSTALL) $(foreach f,$^,"$f") $(DEPTH)/_tests/testing/mochitest/chrome/$(relativesrcdir)
deleted file mode 100644
--- a/image/test/mochitest/invalid.jpg
+++ /dev/null
@@ -1,1 +0,0 @@
-notajpg
deleted file mode 100644
--- a/image/test/mochitest/test_net_failedtoprocess.html
+++ /dev/null
@@ -1,48 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<!--
-Test that a image decoding error producs a net:failed-to-process-uri
-observer event with the nsIURI of the failed image as the subject
--->
-<head>
-  <title>Test for image net:failed-to-process-uri</title>
-  <script type="application/javascript" src="chrome://mochikit/content/MochiKit/packed.js"></script>
-  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
-  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css" />
-</head>
-<body>
-<p id="display"></p>
-<pre id="test">
-<script type="application/javascript">
-
-SimpleTest.waitForExplicitFinish();
-
-const Ci = Components.interfaces;
-const Cc = Components.classes;
-
-var observer = {
-  QueryInterface: function (aIID) {
-    if (aIID.equals(Ci.nsISupports) ||
-        aIID.equals(Ci.nsIObserver))
-      return this;
-    throw Cr.NS_ERROR_NO_INTERFACE;
-  },
-
-  observe: function(subject, topic, data) {
-    ok(topic == "net:failed-to-process-uri", "wrong topic");
-    subject = subject.QueryInterface(Ci.nsIURI);
-    ok(subject.asciiSpec == "chrome://mochitests/content/chrome/image/test/mochitest/invalid.jpg", "wrong subject");
-    SimpleTest.finish();
-  }
-};
-
-var obs = Cc["@mozilla.org/observer-service;1"].getService();
-obs = obs.QueryInterface(Ci.nsIObserverService);
-obs.addObserver(observer, "net:failed-to-process-uri", false);
-
-</script>
-</pre>
-<img src="damon.jpg">
-<img src="invalid.jpg">
-</body>
-</html>
--- a/modules/libpref/src/init/all.js
+++ b/modules/libpref/src/init/all.js
@@ -801,33 +801,21 @@ pref("network.http.redirection-limit", 2
 // NOTE: separate values with comma+space (", "): see bug 576033
 pref("network.http.accept-encoding", "gzip, deflate");
 
 pref("network.http.pipelining"      , false);
 pref("network.http.pipelining.ssl"  , false); // disable pipelining over SSL
 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.read-timeout", 10000);
+pref("network.http.pipelining.maxrequests" , 4);
 
 // Prompt for 307 redirects
 pref("network.http.prompt-temp-redirect", true);
 
-// 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,
 // since inappropriate marking can easily overwhelm bandwidth reservations
 // for certain services (i.e. EF for VoIP, AF4x for interactive video,
 // AF3x for broadcast/streaming video, etc)
 
 // default value for HTTP
 // in a DSCP environment this should be 40 (0x28, or AF11), per RFC-4594,
 // Section 4.8 "High-Throughput Data Service Class"
--- a/netwerk/base/public/nsIRequest.idl
+++ b/netwerk/base/public/nsIRequest.idl
@@ -155,23 +155,16 @@ interface nsIRequest : nsISupports
      */
     const unsigned long LOAD_BACKGROUND = 1 << 0; 
 
     /**************************************************************************
      * The following flags control the flow of data into the cache.
      */
 
     /**
-     *  This flag prevents loading of the request with an HTTP pipeline.
-     *  Generally this is because the resource is expected to take a
-     *  while to load and may cause head of line blocking problems.
-     */
-    const unsigned long INHIBIT_PIPELINE = 1 << 6;
-
-    /**
      * This flag prevents caching of any kind.  It does not, however, prevent
      * cached content from being used to satisfy this request.
      */
     const unsigned long INHIBIT_CACHING = 1 << 7;
 
     /**
      * This flag prevents caching on disk (or other persistent media), which
      * may be needed to preserve privacy.  For HTTPS, this flag is set auto-
--- a/netwerk/protocol/http/SpdySession.cpp
+++ b/netwerk/protocol/http/SpdySession.cpp
@@ -2029,40 +2029,16 @@ SpdySession::TakeHttpConnection()
 nsISocketTransport *
 SpdySession::Transport()
 {
   if (!mConnection)
     return nsnull;
   return mConnection->Transport();
 }
 
-PRUint32
-SpdySession::CancelPipeline(nsresult reason)
-{
-  // we don't pipeline inside spdy, so this isn't an issue
-  return 0;
-}
-
-nsAHttpTransaction::Classifier
-SpdySession::Classification()
-{
-  if (!mConnection)
-    return nsAHttpTransaction::CLASS_GENERAL;
-  return mConnection->Classification();
-}
-
-void
-SpdySession::Classify(nsAHttpTransaction::Classifier newclass)
-{
-  if (!mConnection)
-    return;
-  
-  mConnection->Classify(newclass);
-}
-
 //-----------------------------------------------------------------------------
 // unused methods of nsAHttpTransaction
 // We can be sure of this because SpdySession is only constructed in
 // nsHttpConnection and is never passed out of that object
 //-----------------------------------------------------------------------------
 
 void
 SpdySession::SetConnection(nsAHttpConnection *)
@@ -2083,33 +2059,27 @@ void
 SpdySession::SetSSLConnectFailed()
 {
   NS_ABORT_IF_FALSE(false, "SpdySession::SetSSLConnectFailed()");
 }
 
 bool
 SpdySession::IsDone()
 {
-  return !mStreamTransactionHash.Count();
+  NS_ABORT_IF_FALSE(false, "SpdySession::IsDone()");
+  return false;
 }
 
 nsresult
 SpdySession::Status()
 {
   NS_ABORT_IF_FALSE(false, "SpdySession::Status()");
   return NS_ERROR_UNEXPECTED;
 }
 
-PRUint8
-SpdySession::Caps()
-{
-  NS_ABORT_IF_FALSE(false, "SpdySession::Caps()");
-  return 0;
-}
-
 PRUint32
 SpdySession::Available()
 {
   NS_ABORT_IF_FALSE(false, "SpdySession::Available()");
   return 0;
 }
 
 nsHttpRequestHead *
@@ -2157,52 +2127,16 @@ SpdySession::TakeSubTransactions(
     return NS_ERROR_ALREADY_OPENED;
 
   LOG3(("   taking %d\n", mStreamTransactionHash.Count()));
 
   mStreamTransactionHash.Enumerate(TakeStream, &outTransactions);
   return NS_OK;
 }
 
-nsresult
-SpdySession::AddTransaction(nsAHttpTransaction *)
-{
-  // This API is meant for pipelining, SpdySession's should be
-  // extended with AddStream()
-
-  NS_ABORT_IF_FALSE(false,
-                    "SpdySession::AddTransaction() should not be called");
-
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-PRUint32
-SpdySession::PipelineDepth()
-{
-  return IsDone() ? 0 : 1;
-}
-
-nsresult
-SpdySession::SetPipelinePosition(PRInt32 position)
-{
-  // This API is meant for pipelining, SpdySession's should be
-  // extended with AddStream()
-
-  NS_ABORT_IF_FALSE(false,
-                    "SpdySession::SetPipelinePosition() should not be called");
-
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-PRInt32
-SpdySession::PipelinePosition()
-{
-    return 0;
-}
-
 //-----------------------------------------------------------------------------
 // Pass through methods of nsAHttpConnection
 //-----------------------------------------------------------------------------
 
 nsAHttpConnection *
 SpdySession::Connection()
 {
   NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
@@ -2241,23 +2175,16 @@ SpdySession::IsReused()
 
 nsresult
 SpdySession::PushBack(const char *buf, PRUint32 len)
 {
   return mConnection->PushBack(buf, len);
 }
 
 bool
-SpdySession::IsProxyConnectInProgress()
-{
-    NS_ABORT_IF_FALSE(mConnection, "no connection");
-    return mConnection->IsProxyConnectInProgress();
-}
-
-bool
 SpdySession::LastTransactionExpectedNoContent()
 {
   return mConnection->LastTransactionExpectedNoContent();
 }
 
 void
 SpdySession::SetLastTransactionExpectedNoContent(bool val)
 {
--- a/netwerk/protocol/http/SpdySession.h
+++ b/netwerk/protocol/http/SpdySession.h
@@ -70,19 +70,20 @@ public:
   NS_DECL_NSAHTTPSEGMENTREADER
   NS_DECL_NSAHTTPSEGMENTWRITER
 
   SpdySession(nsAHttpTransaction *, nsISocketTransport *, PRInt32);
   ~SpdySession();
 
   bool AddStream(nsAHttpTransaction *, PRInt32);
   bool CanReuse() { return !mShouldGoAway && !mClosed; }
+  void DontReuse();
   bool RoomForMoreStreams();
 
-  // When the connection is active this is called every 1 second
+  // When the connection is active this is called every 15 seconds
   void ReadTimeoutTick(PRIntervalTime now);
   
   // Idle time represents time since "goodput".. e.g. a data or header frame
   PRIntervalTime IdleTime();
 
   PRUint32 RegisterStreamID(SpdyStream *);
 
   const static PRUint8 kFlag_Control   = 0x80;
--- a/netwerk/protocol/http/nsAHttpConnection.h
+++ b/netwerk/protocol/http/nsAHttpConnection.h
@@ -34,18 +34,18 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef nsAHttpConnection_h__
 #define nsAHttpConnection_h__
 
 #include "nsISupports.h"
-#include "nsAHttpTransaction.h"
 
+class nsAHttpTransaction;
 class nsHttpRequestHead;
 class nsHttpResponseHead;
 class nsHttpConnectionInfo;
 class nsHttpConnection;
 class nsISocketTransport;
 class nsIAsyncInputStream;
 class nsIAsyncOutputStream;
 
@@ -115,67 +115,48 @@ public:
 
     // called by a transaction to get the security info from the socket.
     virtual void GetSecurityInfo(nsISupports **) = 0;
 
     // called by a transaction to determine whether or not the connection is
     // persistent... important in determining the end of a response.
     virtual bool IsPersistent() = 0;
 
-    // called to determine or set if a connection has been reused.
+    // called to determine 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).
     virtual nsresult PushBack(const char *data, PRUint32 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
     // the same connection and work around buggy servers.
     virtual bool LastTransactionExpectedNoContent() = 0;
     virtual void   SetLastTransactionExpectedNoContent(bool) = 0;
 
     // Transfer the base http connection object along with a
     // reference to it to the caller.
     virtual 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 PRUint32 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;
 };
 
 #define NS_DECL_NSAHTTPCONNECTION \
     nsresult OnHeadersAvailable(nsAHttpTransaction *, nsHttpRequestHead *, nsHttpResponseHead *, bool *reset); \
     nsresult ResumeSend(); \
     nsresult ResumeRecv(); \
     void CloseTransaction(nsAHttpTransaction *, nsresult); \
     void GetConnectionInfo(nsHttpConnectionInfo **); \
     nsresult TakeTransport(nsISocketTransport **,    \
                            nsIAsyncInputStream **,   \
                            nsIAsyncOutputStream **); \
     void GetSecurityInfo(nsISupports **); \
     bool IsPersistent(); \
     bool IsReused(); \
-    void DontReuse();  \
     nsresult PushBack(const char *, PRUint32); \
-    bool IsProxyConnectInProgress(); \
     bool LastTransactionExpectedNoContent(); \
-    void SetLastTransactionExpectedNoContent(bool); \
+    void   SetLastTransactionExpectedNoContent(bool); \
     nsHttpConnection *TakeHttpConnection(); \
-    nsISocketTransport *Transport();        \
-    PRUint32 CancelPipeline(nsresult originalReason);   \
-    nsAHttpTransaction::Classifier Classification();    \
-    void Classify(nsAHttpTransaction::Classifier);
+    nsISocketTransport *Transport();
 
 #endif // nsAHttpConnection_h__
--- a/netwerk/protocol/http/nsAHttpTransaction.h
+++ b/netwerk/protocol/http/nsAHttpTransaction.h
@@ -43,49 +43,45 @@
 
 class nsAHttpConnection;
 class nsAHttpSegmentReader;
 class nsAHttpSegmentWriter;
 class nsIInterfaceRequestor;
 class nsIEventTarget;
 class nsITransport;
 class nsHttpRequestHead;
-class nsHttpPipeline;
 
 //----------------------------------------------------------------------------
 // Abstract base class for a HTTP transaction:
 //
 // A transaction is a "sink" for the response data.  The connection pushes
 // data to the transaction by writing to it.  The transaction supports
 // WriteSegments and may refuse to accept data if its buffers are full (its
 // write function returns NS_BASE_STREAM_WOULD_BLOCK in this case).
 //----------------------------------------------------------------------------
 
 class nsAHttpTransaction : public nsISupports
 {
 public:
     // called by the connection when it takes ownership of the transaction.
     virtual void SetConnection(nsAHttpConnection *) = 0;
-
-    // used to obtain the connection associated with this transaction
     virtual nsAHttpConnection *Connection() = 0;
 
     // called by the connection to get security callbacks to set on the
     // socket transport.
     virtual void GetSecurityCallbacks(nsIInterfaceRequestor **,
                                       nsIEventTarget **) = 0;
 
     // called to report socket status (see nsITransportEventSink)
     virtual void OnTransportStatus(nsITransport* transport,
                                    nsresult status, PRUint64 progress) = 0;
 
     // called to check the transaction status.
     virtual bool     IsDone() = 0;
     virtual nsresult Status() = 0;
-    virtual PRUint8  Caps() = 0;
 
     // called to find out how much request data is available for writing.
     virtual PRUint32 Available() = 0;
 
     // called to read request data from the transaction.
     virtual nsresult ReadSegments(nsAHttpSegmentReader *reader,
                                   PRUint32 count, PRUint32 *countRead) = 0;
 
@@ -113,83 +109,35 @@ public:
     // 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<nsRefPtr<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 PRUint32 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(PRInt32) = 0;
-    virtual PRInt32  PipelinePosition() = 0;
-
-    // If we used rtti this would be the result of doing
-    // dynamic_cast<nsHttpPipeline *>(this).. i.e. it can be nsnull for
-    // non pipeline implementations of nsAHttpTransaction
-    virtual nsHttpPipeline *QueryPipeline() { return nsnull; }
-    
-    // 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
-    };
 };
 
 #define NS_DECL_NSAHTTPTRANSACTION \
     void SetConnection(nsAHttpConnection *); \
     nsAHttpConnection *Connection(); \
     void GetSecurityCallbacks(nsIInterfaceRequestor **, \
                               nsIEventTarget **);       \
     void OnTransportStatus(nsITransport* transport, \
                            nsresult status, PRUint64 progress); \
     bool     IsDone(); \
     nsresult Status(); \
-    PRUint8  Caps();   \
     PRUint32 Available(); \
     nsresult ReadSegments(nsAHttpSegmentReader *, PRUint32, PRUint32 *); \
     nsresult WriteSegments(nsAHttpSegmentWriter *, PRUint32, PRUint32 *); \
     void     Close(nsresult reason);                                    \
     void     SetSSLConnectFailed();                                     \
     nsHttpRequestHead *RequestHead();                                   \
     PRUint32 Http1xTransactionCount();                                  \
-    nsresult TakeSubTransactions(nsTArray<nsRefPtr<nsAHttpTransaction> > &outTransactions); \
-    nsresult AddTransaction(nsAHttpTransaction *);                      \
-    PRUint32 PipelineDepth();                                           \
-    nsresult SetPipelinePosition(PRInt32);                              \
-    PRInt32  PipelinePosition();
+    nsresult TakeSubTransactions(nsTArray<nsRefPtr<nsAHttpTransaction> > &outTransactions);
 
 //-----------------------------------------------------------------------------
 // nsAHttpSegmentReader
 //-----------------------------------------------------------------------------
 
 class nsAHttpSegmentReader
 {
 public:
--- a/netwerk/protocol/http/nsHttp.cpp
+++ b/netwerk/protocol/http/nsHttp.cpp
@@ -182,22 +182,16 @@ nsHttp::DestroyAtomTable()
     }
 
     if (sLock) {
         delete sLock;
         sLock = nsnull;
     }
 }
 
-Mutex *
-nsHttp::GetLock()
-{
-    return sLock;
-}
-
 // this function may be called from multiple threads
 nsHttpAtom
 nsHttp::ResolveAtom(const char *str)
 {
     nsHttpAtom atom = { nsnull };
 
     if (!str || !sAtomTable.ops)
         return atom;
--- a/netwerk/protocol/http/nsHttp.h
+++ b/netwerk/protocol/http/nsHttp.h
@@ -135,16 +135,19 @@ typedef PRUint8 nsHttpVersion;
 // such as HTTP upgrade which are nonsensical for SPDY, it is not the
 // SPDY configuration variable.
 #define NS_HTTP_DISALLOW_SPDY        (1<<7)
 
 //-----------------------------------------------------------------------------
 // some default values
 //-----------------------------------------------------------------------------
 
+// hard upper limit on the number of requests that can be pipelined
+#define NS_HTTP_MAX_PIPELINED_REQUESTS 8 
+
 #define NS_HTTP_DEFAULT_PORT  80
 #define NS_HTTPS_DEFAULT_PORT 443
 
 #define NS_HTTP_HEADER_SEPS ", \t"
 
 //-----------------------------------------------------------------------------
 // http atoms...
 //-----------------------------------------------------------------------------
@@ -161,21 +164,16 @@ struct nsHttpAtom
     const char *_val;
 };
 
 struct nsHttp
 {
     static nsresult CreateAtomTable();
     static void DestroyAtomTable();
 
-    // The mutex is valid any time the Atom Table is valid
-    // This mutex is used in the unusual case that the network thread and
-    // main thread might access the same data
-    static mozilla::Mutex *GetLock();
-
     // will dynamically add atoms to the table if they don't already exist
     static nsHttpAtom ResolveAtom(const char *);
     static nsHttpAtom ResolveAtom(const nsACString &s)
     {
         return ResolveAtom(PromiseFlatCString(s).get());
     }
 
     // returns true if the specified token [start,end) is valid per RFC 2616
--- a/netwerk/protocol/http/nsHttpAtomList.h
+++ b/netwerk/protocol/http/nsHttpAtomList.h
@@ -52,17 +52,16 @@
 
 HTTP_ATOM(Accept,                    "Accept")
 HTTP_ATOM(Accept_Encoding,           "Accept-Encoding")
 HTTP_ATOM(Accept_Language,           "Accept-Language")
 HTTP_ATOM(Accept_Ranges,             "Accept-Ranges")
 HTTP_ATOM(Age,                       "Age")
 HTTP_ATOM(Allow,                     "Allow")
 HTTP_ATOM(Alternate_Protocol,        "Alternate-Protocol")
-HTTP_ATOM(Assoc_Req,                 "Assoc-Req")
 HTTP_ATOM(Authentication,            "Authentication")
 HTTP_ATOM(Authorization,             "Authorization")
 HTTP_ATOM(Cache_Control,             "Cache-Control")
 HTTP_ATOM(Connection,                "Connection")
 HTTP_ATOM(Content_Disposition,       "Content-Disposition")
 HTTP_ATOM(Content_Encoding,          "Content-Encoding")
 HTTP_ATOM(Content_Language,          "Content-Language")
 HTTP_ATOM(Content_Length,            "Content-Length")
--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@@ -42,17 +42,16 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHttpChannel.h"
 #include "nsHttpHandler.h"
-#include "nsStandardURL.h"
 #include "nsIApplicationCacheService.h"
 #include "nsIApplicationCacheContainer.h"
 #include "nsIAuthInformation.h"
 #include "nsIStringBundle.h"
 #include "nsIIDNService.h"
 #include "nsIStreamListenerTee.h"
 #include "nsISeekableStream.h"
 #include "nsMimeTypes.h"
@@ -66,17 +65,16 @@
 #include "nsDNSPrefetch.h"
 #include "nsChannelClassifier.h"
 #include "nsIRedirectResultListener.h"
 #include "mozilla/TimeStamp.h"
 #include "mozilla/Telemetry.h"
 #include "nsDOMError.h"
 #include "nsAlgorithm.h"
 #include "sampler.h"
-#include "nsIConsoleService.h"
 
 using namespace mozilla;
 
 // Device IDs for various cache types
 const char kDiskDeviceID[] = "disk";
 const char kMemoryDeviceID[] = "memory";
 const char kOfflineDeviceID[] = "offline";
 
@@ -497,27 +495,26 @@ nsHttpChannel::SetupTransaction()
 
     NS_ENSURE_TRUE(!mTransaction, NS_ERROR_ALREADY_INITIALIZED);
 
     nsresult rv;
 
     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)
+        //   (1) pipelining has been explicitly disabled
+        //   (2) request corresponds to a top-level document load (link click)
+        //   (3) request method is non-idempotent
         //
-        if (!mAllowPipelining ||
-           (mLoadFlags & (LOAD_INITIAL_DOCUMENT_URI | INHIBIT_PIPELINE)) ||
+        // XXX does the toplevel document check really belong here?  or, should
+        //     we push it out entirely to necko consumers?
+        //
+        if (!mAllowPipelining || (mLoadFlags & LOAD_INITIAL_DOCUMENT_URI) ||
             !(mRequestHead.Method() == nsHttp::Get ||
               mRequestHead.Method() == nsHttp::Head ||
-              mRequestHead.Method() == nsHttp::Options ||
               mRequestHead.Method() == nsHttp::Propfind ||
               mRequestHead.Method() == nsHttp::Proppatch)) {
             LOG(("  pipelining disallowed\n"));
             mCaps &= ~NS_HTTP_ALLOW_PIPELINING;
         }
     }
 
     if (!mAllowSpdy)
@@ -766,20 +763,16 @@ nsHttpChannel::CallOnStartRequest()
     LOG(("  calling mListener->OnStartRequest\n"));
     nsresult rv = mListener->OnStartRequest(this, mListenerContext);
     if (NS_FAILED(rv)) return rv;
 
     // install stream converter if required
     rv = ApplyContentConversions();
     if (NS_FAILED(rv)) return rv;
 
-    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->Doom();
         CloseCacheEntry(false);
     }
 
     if (!mCanceled) {
         // create offline cache entry if offline caching was requested
@@ -1714,127 +1707,16 @@ nsHttpChannel::Hash(const char *buf, nsA
     NS_ENSURE_SUCCESS(rv, rv);
 
     rv = mHasher->Finish(true, hash);
     NS_ENSURE_SUCCESS(rv, rv);
 
     return NS_OK;
 }
 
-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;
-
-    const char *assoc_val = mResponseHead->PeekHeader(nsHttp::Assoc_Req);
-    if (!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.
-
-        const char *pragma_val = mResponseHead->PeekHeader(nsHttp::Pragma);
-        if (!pragma_val ||
-            !nsHttp::FindToken(pragma_val, "X-Verify-Assoc-Req",
-                               HTTP_HEADER_VALUE_SEPS))
-            return NS_OK;
-    }
-
-    char *method = net_FindCharNotInSet(assoc_val, HTTP_LWS);
-    if (!method)
-        return NS_OK;
-    
-    bool equals;
-    char *endofmethod;
-    
-    assoc_val = nsnull;
-    endofmethod = net_FindCharInSet(method, HTTP_LWS);
-    if (endofmethod)
-        assoc_val = net_FindCharNotInSet(endofmethod, HTTP_LWS);
-    if (!assoc_val)
-        return NS_OK;
-    
-    // check the method
-    PRInt32 methodlen = PL_strlen(mRequestHead.Method().get());
-    if ((methodlen != (endofmethod - method)) ||
-        PL_strncmp(method,
-                   mRequestHead.Method().get(),
-                   endofmethod - method)) {
-        LOG(("  Assoc-Req failure Method %s", method));
-        if (mConnectionInfo)
-            gHttpHandler->ConnMgr()->
-                PipelineFeedbackInfo(mConnectionInfo,
-                                     nsHttpConnectionMgr::RedCorruptedContent,
-                                     nsnull, 0);
-
-        nsCOMPtr<nsIConsoleService> consoleService =
-            do_GetService(NS_CONSOLESERVICE_CONTRACTID);
-        if (consoleService) {
-            nsAutoString message
-                (NS_LITERAL_STRING("Failed Assoc-Req. Received "));
-            AppendASCIItoUTF16(
-                mResponseHead->PeekHeader(nsHttp::Assoc_Req),
-                message);
-            message += NS_LITERAL_STRING(" expected method ");
-            AppendASCIItoUTF16(mRequestHead.Method().get(), 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_val)) ||
-        !assoc_url)
-        return NS_OK;
-
-    mURI->Equals(assoc_url, &equals);
-    if (!equals) {
-        LOG(("  Assoc-Req failure URL %s", assoc_val));
-        if (mConnectionInfo)
-            gHttpHandler->ConnMgr()->
-                PipelineFeedbackInfo(mConnectionInfo,
-                                     nsHttpConnectionMgr::RedCorruptedContent,
-                                     nsnull, 0);
-
-        nsCOMPtr<nsIConsoleService> consoleService =
-            do_GetService(NS_CONSOLESERVICE_CONTRACTID);
-        if (consoleService) {
-            nsAutoString message
-                (NS_LITERAL_STRING("Failed Assoc-Req. Received "));
-            AppendASCIItoUTF16(
-                mResponseHead->PeekHeader(nsHttp::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>
 //-----------------------------------------------------------------------------
 
 nsresult
 nsHttpChannel::SetupByteRangeRequest(PRUint32 partialLen)
 {
     // cached content has been found to be partial, add necessary request
@@ -1968,43 +1850,16 @@ nsHttpChannel::ProcessNotModified()
     if (mCustomConditionalRequest) {
         LOG(("Bypassing ProcessNotModified due to custom conditional headers")); 
         return NS_ERROR_FAILURE;
     }
 
     NS_ENSURE_TRUE(mCachedResponseHead, NS_ERROR_NOT_INITIALIZED);
     NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_INITIALIZED);
 
-    // 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.
-
-    nsCAutoString lastModified;
-    nsCAutoString lastModified304;
-
-    rv = mCachedResponseHead->GetHeader(nsHttp::Last_Modified,
-                                        lastModified);
-    if (NS_SUCCEEDED(rv))
-        rv = mResponseHead->GetHeader(nsHttp::Last_Modified, 
-                                      lastModified304);
-    if (NS_SUCCEEDED(rv) && !lastModified304.Equals(lastModified)) {
-        LOG(("Cache Entry and 304 Last-Modified Headers Do Not Match "
-             "%s and %s\n", lastModified.get(), lastModified304.get()));
-
-        mCacheEntry->Doom();
-        if (mConnectionInfo)
-            gHttpHandler->ConnMgr()->
-                PipelineFeedbackInfo(mConnectionInfo,
-                                     nsHttpConnectionMgr::RedCorruptedContent,
-                                     nsnull, 0);
-    }
-
     // merge any new headers with the cached response headers
     rv = mCachedResponseHead->UpdateHeaders(mResponseHead->Headers());
     if (NS_FAILED(rv)) return rv;
 
     // update the cached response head
     nsCAutoString head;
     mCachedResponseHead->Flatten(head, true);
     rv = mCacheEntry->SetMetaDataElement("response-head", head.get());
--- a/netwerk/protocol/http/nsHttpChannel.h
+++ b/netwerk/protocol/http/nsHttpChannel.h
@@ -177,17 +177,16 @@ private:
     nsresult ContinueProcessRedirection(nsresult);
     nsresult ContinueProcessRedirectionAfterFallback(nsresult);
     bool     ShouldSSLProxyResponseContinue(PRUint32 httpStatus);
     nsresult ProcessFailedSSLConnect(PRUint32 httpStatus);
     nsresult ProcessFallback(bool *waitingForRedirectCallback);
     nsresult ContinueProcessFallback(nsresult);
     bool     ResponseWouldVary();
     void     HandleAsyncAbort();
-    nsresult EnsureAssocReq();
 
     nsresult ContinueOnStartRequest1(nsresult);
     nsresult ContinueOnStartRequest2(nsresult);
     nsresult ContinueOnStartRequest3(nsresult);
 
     // redirection specific methods
     void     HandleAsyncRedirect();
     nsresult ContinueHandleAsyncRedirect(nsresult);
--- a/netwerk/protocol/http/nsHttpConnection.cpp
+++ b/netwerk/protocol/http/nsHttpConnection.cpp
@@ -67,32 +67,31 @@ static NS_DEFINE_CID(kSocketTransportSer
 using namespace mozilla::net;
 
 //-----------------------------------------------------------------------------
 // nsHttpConnection <public>
 //-----------------------------------------------------------------------------
 
 nsHttpConnection::nsHttpConnection()
     : mTransaction(nsnull)
+    , mLastReadTime(0)
+    , mIdleTimeout(0)
     , mConsiderReusedAfterInterval(0)
     , mConsiderReusedAfterEpoch(0)
     , mCurrentBytesRead(0)
     , mMaxBytesRead(0)
     , mTotalBytesRead(0)
     , mKeepAlive(true) // assume to keep-alive by default
     , mKeepAliveMask(true)
     , mSupportsPipelining(false) // assume low-grade server
     , mIsReused(false)
     , mCompletedProxyConnect(false)
     , mLastTransactionExpectedNoContent(false)
     , mIdleMonitoring(false)
-    , mProxyConnectInProgress(false)
     , mHttp1xTransactionCount(0)
-    , mRemainingConnectionUses(0xffffffff)
-    , mClassification(nsAHttpTransaction::CLASS_GENERAL)
     , mNPNComplete(false)
     , mSetupNPNCalled(false)
     , mUsingSpdy(false)
     , mPriority(nsISupportsPriority::PRIORITY_NORMAL)
     , mReportedSpdy(false)
     , mEverUsedSpdy(false)
 {
     LOG(("Creating nsHttpConnection @%x\n", this));
@@ -137,35 +136,30 @@ nsHttpConnection::~nsHttpConnection()
 
 nsresult
 nsHttpConnection::Init(nsHttpConnectionInfo *info,
                        PRUint16 maxHangTime,
                        nsISocketTransport *transport,
                        nsIAsyncInputStream *instream,
                        nsIAsyncOutputStream *outstream,
                        nsIInterfaceRequestor *callbacks,
-                       nsIEventTarget *callbackTarget,
-                       PRIntervalTime rtt)
+                       nsIEventTarget *callbackTarget)
 {
     NS_ABORT_IF_FALSE(transport && instream && outstream,
                       "invalid socket information");
     LOG(("nsHttpConnection::Init [this=%p "
-         "transport=%p instream=%p outstream=%p rtt=%d]\n",
-         this, transport, instream, outstream,
-         PR_IntervalToMilliseconds(rtt)));
+         "transport=%p instream=%p outstream=%p]\n",
+         this, transport, instream, outstream));
 
     NS_ENSURE_ARG_POINTER(info);
     NS_ENSURE_TRUE(!mConnInfo, NS_ERROR_ALREADY_INITIALIZED);
 
     mConnInfo = info;
+    mMaxHangTime = PR_SecondsToInterval(maxHangTime);
     mLastReadTime = PR_IntervalNow();
-    mSupportsPipelining =
-        gHttpHandler->ConnMgr()->SupportsPipelining(mConnInfo);
-    mRtt = rtt;
-    mMaxHangTime = PR_SecondsToInterval(maxHangTime);
 
     mSocketTransport = transport;
     mSocketIn = instream;
     mSocketOut = outstream;
     nsresult rv = mSocketTransport->SetEventSink(this, nsnull);
     NS_ENSURE_SUCCESS(rv, rv);
 
     mCallbacks = callbacks;
@@ -339,19 +333,16 @@ nsHttpConnection::Activate(nsAHttpTransa
 
     mPriority = pri;
     if (mTransaction && mUsingSpdy)
         return AddTransaction(trans, pri);
 
     NS_ENSURE_ARG_POINTER(trans);
     NS_ENSURE_TRUE(!mTransaction, NS_ERROR_IN_PROGRESS);
 
-    // reset the read timers to wash away any idle time
-    mLastReadTime = PR_IntervalNow();
-
     // Update security callbacks
     nsCOMPtr<nsIInterfaceRequestor> callbacks;
     nsCOMPtr<nsIEventTarget>        callbackTarget;
     trans->GetSecurityCallbacks(getter_AddRefs(callbacks),
                                 getter_AddRefs(callbackTarget));
     if (callbacks != mCallbacks) {
         mCallbacks.swap(callbacks);
         if (callbacks)
@@ -373,17 +364,16 @@ nsHttpConnection::Activate(nsAHttpTransa
 
     // need to handle HTTP CONNECT tunnels if this is the first time if
     // we are tunneling through a proxy
     if (((mConnInfo->UsingSSL() && mConnInfo->UsingHttpProxy()) ||
          mConnInfo->ShouldForceConnectMethod()) && !mCompletedProxyConnect) {
         rv = SetupProxyConnect();
         if (NS_FAILED(rv))
             goto failed_activation;
-        mProxyConnectInProgress = true;
     }
 
     // Clear the per activation counter
     mCurrentBytesRead = 0;
 
     // The overflow state is not needed between activations
     mInputOverflow = nsnull;
 
@@ -530,45 +520,26 @@ nsHttpConnection::DontReuse()
 {
     mKeepAliveMask = false;
     mKeepAlive = false;
     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();
-}
-
 bool
 nsHttpConnection::CanReuse()
 {
-    if ((mTransaction ? mTransaction->PipelineDepth() : 0) >=
-        mRemainingConnectionUses) {
-        return false;
-    }
-
     bool canReuse;
     
     if (mUsingSpdy)
         canReuse = mSpdySession->CanReuse();
     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.
 
     PRUint32 dataSize;
@@ -643,29 +614,31 @@ nsHttpConnection::IsAlive()
 
 bool
 nsHttpConnection::SupportsPipelining(nsHttpResponseHead *responseHead)
 {
     // SPDY supports infinite parallelism, so no need to pipeline.
     if (mUsingSpdy)
         return false;
 
+    // XXX there should be a strict mode available that disables this
+    // blacklisting.
+
     // assuming connection is HTTP/1.1 with keep-alive enabled
     if (mConnInfo->UsingHttpProxy() && !mConnInfo->UsingSSL()) {
         // XXX check for bad proxy servers...
         return true;
     }
 
+    // XXX what about checking for a Via header? (transparent proxies)
+
     // check for bad origin servers
     const char *val = responseHead->PeekHeader(nsHttp::Server);
-
-    // 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)
-        return true;
+        return false; // no header, no love
 
     // 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] = {
         { nsnull }, { nsnull }, { nsnull }, { nsnull },                 // a - d
         { "EFAServer/", nsnull },                                       // e
@@ -682,18 +655,16 @@ nsHttpConnection::SupportsPipelining(nsH
     };  
 
     int index = val[0] - 'A'; // the whole table begins with capital letters
     if ((index >= 0) && (index <= 25))
     {
         for (int i = 0; bad_servers[index][i] != nsnull; i++) {
             if (!PL_strncmp (val, bad_servers[index][i], strlen (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;
 }
@@ -739,110 +710,60 @@ nsHttpConnection::OnHeadersAvailable(nsA
 
     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 (val && !PL_strcasecmp(val, "keep-alive"))
             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 (val && !PL_strcasecmp(val, "close")) {
+        if (val && !PL_strcasecmp(val, "close")) 
             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);
         }
     }
     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 &&
-        responseHead->Status() != 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;
     if (mKeepAlive) {
         val = responseHead->PeekHeader(nsHttp::Keep_Alive);
 
         if (!mUsingSpdy) {
             const char *cp = PL_strcasestr(val, "timeout=");
             if (cp)
                 mIdleTimeout = PR_SecondsToInterval((PRUint32) atoi(cp + 8));
             else
-                mIdleTimeout = gHttpHandler->SpdyTimeout();
-
-            cp = PL_strcasestr(val, "max=");
-            if (cp) {
-                int val = atoi(cp + 4);
-                if (val > 0) {
-                    foundKeepAliveMax = true;
-                    mRemainingConnectionUses = static_cast<PRUint32>(val);
-                }
-            }
+                mIdleTimeout = gHttpHandler->IdleTimeout();
         }
         else {
             mIdleTimeout = gHttpHandler->SpdyTimeout();
         }
         
-        LOG(("Connection can be reused [this=%p idle-timeout=%usec]\n",
+        LOG(("Connection can be reused [this=%x idle-timeout=%usec]\n",
              this, PR_IntervalToSeconds(mIdleTimeout)));
     }
 
-    if (!foundKeepAliveMax && mRemainingConnectionUses && !mUsingSpdy)
-        --mRemainingConnectionUses;
-
     if (!mProxyConnectStream)
         HandleAlternateProtocol(responseHead);
 
     // if we're doing an SSL proxy connect, then we need to check whether or not
     // the connect was successful.  if so, then we have to reset the transaction
     // and step-up the socket connection to SSL. finally, we have to wake up the
     // socket write request.
     if (mProxyConnectStream) {
@@ -954,66 +875,18 @@ nsHttpConnection::ReadTimeoutTick(PRInte
 
     // Spdy in the future actually should implement some timeout handling
     // using the SPDY ping frame.
     if (mSpdySession) {
         mSpdySession->ReadTimeoutTick(now);
         return;
     }
     
-    PRIntervalTime delta = PR_IntervalNow() - 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.
-
-    const PRIntervalTime k1000ms = PR_MillisecondsToInterval(1000);
-
-    if (delta < k1000ms)
-        return;
-
-    PRUint32 pipelineDepth = mTransaction->PipelineDepth();
-
-    // 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));
+    // Pending patches places pipeline rescheduling code will go here
 
-    if (pipelineDepth > 1) {
-        nsHttpPipeline *pipeline = mTransaction->QueryPipeline();
-        NS_ABORT_IF_FALSE(pipeline, "pipelinedepth > 1 without pipeline");
-        // code this defensively for the moment and check for null in opt build
-        if (pipeline)
-            pipeline->CancelPipeline(NS_ERROR_NET_TIMEOUT);
-    }
-    
-    if (delta < gHttpHandler->GetPipelineTimeout())
-        return;
-
-    if (pipelineDepth <= 1 && !mTransaction->PipelinePosition())
-        return;
-    
-    // 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);
 }
 
 void
 nsHttpConnection::GetSecurityInfo(nsISupports **secinfo)
 {
     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 
     if (mSocketTransport) {
@@ -1052,24 +925,16 @@ nsHttpConnection::ResumeSend()
 
 nsresult
 nsHttpConnection::ResumeRecv()
 {
     LOG(("nsHttpConnection::ResumeRecv [this=%p]\n", this));
 
     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 
-    // the mLastReadTime timestamp is used for finding slowish readers
-    // and can be pretty sensitive. For that reason we actually reset it
-    // when we ask to read (resume recv()) so that when we get called back
-    // with actual read data in OnSocketReadable() we are only measuring
-    // the latency between those two acts and not all the processing that
-    // may get done before the ResumeRecv() call
-    mLastReadTime = PR_IntervalNow();
-
     if (mSocketIn)
         return mSocketIn->AsyncWait(this, 0, 0, nsnull);
 
     NS_NOTREACHED("no socket input stream");
     return NS_ERROR_UNEXPECTED;
 }
 
 void
@@ -1182,18 +1047,17 @@ nsHttpConnection::OnReadSegment(const ch
         mSocketOutCondition = NS_OK; // reset condition
 
     return mSocketOutCondition;
 }
 
 nsresult
 nsHttpConnection::OnSocketWritable()
 {
-    LOG(("nsHttpConnection::OnSocketWritable [this=%p] host=%s\n",
-         this, mConnInfo->Host()));
+    LOG(("nsHttpConnection::OnSocketWritable [this=%x]\n", this));
 
     nsresult rv;
     PRUint32 n;
     bool again = true;
 
     do {
         mSocketOutCondition = NS_OK;
 
@@ -1225,17 +1089,16 @@ nsHttpConnection::OnSocketWritable()
         }
         else {
             if (!mReportedSpdy) {
                 mReportedSpdy = true;
                 gHttpHandler->ConnMgr()->ReportSpdyConnection(this, mUsingSpdy);
             }
 
             LOG(("  writing transaction request stream\n"));
-            mProxyConnectInProgress = false;
             rv = mTransaction->ReadSegments(this, nsIOService::gDefaultSegmentSize, &n);
         }
 
         LOG(("  ReadSegments returned [rv=%x read=%u sock-cond=%x]\n",
             rv, n, mSocketOutCondition));
 
         // XXX some streams return NS_BASE_STREAM_CLOSED to indicate EOF.
         if (rv == NS_BASE_STREAM_CLOSED) {
@@ -1263,17 +1126,17 @@ nsHttpConnection::OnSocketWritable()
             // must wait for the server's response.  we manufacture a status message
             // here to reflect the fact that we are waiting.  this message will be
             // trumped (overwritten) if the server responds quickly.
             //
             mTransaction->OnTransportStatus(mSocketTransport,
                                             nsISocketTransport::STATUS_WAITING_FOR,
                                             LL_ZERO);
 
-            rv = ResumeRecv(); // start reading
+            rv = mSocketIn->AsyncWait(this, 0, 0, nsnull); // start reading
             again = false;
         }
         // write more to the socket until error or end-of-request...
     } while (again);
 
     return rv;
 }
 
@@ -1302,63 +1165,24 @@ nsHttpConnection::OnWriteSegment(char *b
 }
 
 nsresult
 nsHttpConnection::OnSocketReadable()
 {
     LOG(("nsHttpConnection::OnSocketReadable [this=%x]\n", this));
 
     PRIntervalTime now = PR_IntervalNow();
-    PRIntervalTime delta = now - mLastReadTime;
 
-    if (mKeepAliveMask && (delta >= mMaxHangTime)) {
+    if (mKeepAliveMask && ((now - mLastReadTime) >= 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;
-
-    const PRIntervalTime k400ms  = PR_MillisecondsToInterval(400);
-    const PRIntervalTime k1200ms = PR_MillisecondsToInterval(1200);
-
-    if (delta > k1200ms) {
-        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 (mTransaction->PipelineDepth() > 1) {
-            nsHttpPipeline *pipeline = mTransaction->QueryPipeline();
-            NS_ABORT_IF_FALSE(pipeline, "pipelinedepth > 1 without pipeline");
-            // code this defensively for the moment and check for null
-            if (pipeline)
-                pipeline->CancelPipeline(NS_ERROR_NET_TIMEOUT);
-        }
-    }
-    else if (delta > k400ms) {
-        gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-            mConnInfo, nsHttpConnectionMgr::BadSlowReadMinor, this, 0);
-    }
-
     mLastReadTime = now;
 
     nsresult rv;
     PRUint32 n;
     bool again = true;
 
     do {
         rv = mTransaction->WriteSegments(this, nsIOService::gDefaultSegmentSize, &n);
@@ -1370,17 +1194,17 @@ nsHttpConnection::OnSocketReadable()
             again = false;
         }
         else {
             mCurrentBytesRead += n;
             mTotalBytesRead += n;
             if (NS_FAILED(mSocketInCondition)) {
                 // continue waiting for the socket if necessary...
                 if (mSocketInCondition == NS_BASE_STREAM_WOULD_BLOCK)
-                    rv = ResumeRecv();
+                    rv = mSocketIn->AsyncWait(this, 0, 0, nsnull);
                 else
                     rv = mSocketInCondition;
                 again = false;
             }
         }
         // read more from the socket until error...
     } while (again);
 
--- a/netwerk/protocol/http/nsHttpConnection.h
+++ b/netwerk/protocol/http/nsHttpConnection.h
@@ -36,35 +36,31 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef nsHttpConnection_h__
 #define nsHttpConnection_h__
 
 #include "nsHttp.h"
 #include "nsHttpConnectionInfo.h"
+#include "nsAHttpConnection.h"
 #include "nsAHttpTransaction.h"
-#include "nsHttpPipeline.h"
 #include "nsXPIDLString.h"
 #include "nsCOMPtr.h"
 #include "nsAutoPtr.h"
 #include "prinrval.h"
 #include "SpdySession.h"
-#include "mozilla/TimeStamp.h"
 
 #include "nsIStreamListener.h"
 #include "nsISocketTransport.h"
 #include "nsIAsyncInputStream.h"
 #include "nsIAsyncOutputStream.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsIEventTarget.h"
 
-class nsHttpRequestHead;
-class nsHttpResponseHead;
-
 //-----------------------------------------------------------------------------
 // nsHttpConnection - represents a connection to a HTTP server (or proxy)
 //
 // NOTE: this objects lives on the socket thread only.  it should not be
 // accessed from any other thread.
 //-----------------------------------------------------------------------------
 
 class nsHttpConnection : public nsAHttpSegmentReader
@@ -89,46 +85,41 @@ public:
     // Initialize the connection:
     //  info        - specifies the connection parameters.
     //  maxHangTime - limits the amount of time this connection can spend on a
     //                single transaction before it should no longer be kept 
     //                alive.  a value of 0xffff indicates no limit.
     nsresult Init(nsHttpConnectionInfo *info, PRUint16 maxHangTime,
                   nsISocketTransport *, nsIAsyncInputStream *,
                   nsIAsyncOutputStream *, nsIInterfaceRequestor *,
-                  nsIEventTarget *, PRIntervalTime);
+                  nsIEventTarget *);
 
     // Activate causes the given transaction to be processed on this
     // connection.  It fails if there is already an existing transaction unless
     // a multiplexing protocol such as SPDY is being used
     nsresult Activate(nsAHttpTransaction *, PRUint8 caps, PRInt32 pri);
 
     // Close the underlying socket transport.
     void Close(nsresult reason);
 
     //-------------------------------------------------------------------------
     // XXX document when these are ok to call
 
-    bool     SupportsPipelining();
+    bool     SupportsPipelining() { return mSupportsPipelining; }
     bool     IsKeepAlive() { return mUsingSpdy ||
                                     (mKeepAliveMask && mKeepAlive); }
     bool     CanReuse();   // can this connection be reused?
     bool     CanDirectlyActivate();
 
     // Returns time in seconds for how long connection can be reused.
     PRUint32 TimeToLive();
 
     void     DontReuse();
     void     DropTransport() { DontReuse(); mSocketTransport = 0; }
 
-    bool     IsProxyConnectInProgress()
-    {
-        return mProxyConnectInProgress;
-    }
-
     bool     LastTransactionExpectedNoContent()
     {
         return mLastTransactionExpectedNoContent;
     }
 
     void     SetLastTransactionExpectedNoContent(bool val)
     {
         mLastTransactionExpectedNoContent = val;
@@ -162,28 +153,19 @@ public:
     // connection pool, the nsHttpConnection still reads errors and hangups
     // on the socket so that it can be proactively released if the server
     // initiates a termination. Only call on socket thread.
     void BeginIdleMonitoring();
     void EndIdleMonitoring();
 
     bool UsingSpdy() { return mUsingSpdy; }
 
-    // When the connection is active this is called every 1 second
+    // When the connection is active this is called every 15 seconds
     void  ReadTimeoutTick(PRIntervalTime now);
 
-    nsAHttpTransaction::Classifier Classification() { return mClassification; }
-    void Classify(nsAHttpTransaction::Classifier newclass)
-    {
-        mClassification = newclass;
-    }
-
-    // When the connection is active this is called every second
-    void  ReadTimeoutTick();
-
 private:
     // called to cause the underlying socket to start speaking SSL
     nsresult ProxyStartSSL();
 
     nsresult OnTransactionDone(nsresult reason);
     nsresult OnSocketWritable();
     nsresult OnSocketReadable();
 
@@ -223,49 +205,39 @@ private:
     // transaction is open, otherwise it is null.
     nsRefPtr<nsAHttpTransaction>    mTransaction;
 
     nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
     nsCOMPtr<nsIEventTarget>        mCallbackTarget;
 
     nsRefPtr<nsHttpConnectionInfo> mConnInfo;
 
-    PRIntervalTime                  mLastReadTime;
+    PRUint32                        mLastReadTime;
     PRIntervalTime                  mMaxHangTime;    // max download time before dropping keep-alive status
     PRIntervalTime                  mIdleTimeout;    // value of keep-alive: timeout=
     PRIntervalTime                  mConsiderReusedAfterInterval;
     PRIntervalTime                  mConsiderReusedAfterEpoch;
     PRInt64                         mCurrentBytesRead;   // data read per activation
     PRInt64                         mMaxBytesRead;       // max read in 1 activation
     PRInt64                         mTotalBytesRead;     // total data read
 
     nsRefPtr<nsIAsyncInputStream>   mInputOverflow;
 
-    PRIntervalTime                  mRtt;
-
     bool                            mKeepAlive;
     bool                            mKeepAliveMask;
     bool                            mSupportsPipelining;
     bool                            mIsReused;
     bool                            mCompletedProxyConnect;
     bool                            mLastTransactionExpectedNoContent;
     bool                            mIdleMonitoring;
-    bool                            mProxyConnectInProgress;
 
     // The number of <= HTTP/1.1 transactions performed on this connection. This
     // excludes spdy transactions.
     PRUint32                        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.
-    PRUint32                        mRemainingConnectionUses;
-
-    nsAHttpTransaction::Classifier  mClassification;
-
     // SPDY related
     bool                            mNPNComplete;
     bool                            mSetupNPNCalled;
     bool                            mUsingSpdy;
     nsRefPtr<mozilla::net::SpdySession> mSpdySession;
     PRInt32                         mPriority;
     bool                            mReportedSpdy;
 
--- a/netwerk/protocol/http/nsHttpConnectionInfo.h
+++ b/netwerk/protocol/http/nsHttpConnectionInfo.h
@@ -120,17 +120,16 @@ public:
     PRInt32       Port() const           { return mPort; }
     nsProxyInfo  *ProxyInfo()            { return mProxyInfo; }
     bool          UsingHttpProxy() const { return mUsingHttpProxy; }
     bool          UsingSSL() const       { return mUsingSSL; }
     PRInt32       DefaultPort() const    { return mUsingSSL ? NS_HTTPS_DEFAULT_PORT : NS_HTTP_DEFAULT_PORT; }
     void          SetAnonymous(bool anon)         
                                          { mHashKey.SetCharAt(anon ? 'A' : '.', 2); }
     bool          GetAnonymous()         { return mHashKey.CharAt(2) == 'A'; }
-
     bool          ShouldForceConnectMethod();
     const nsCString &GetHost() { return mHost; }
 
 private:
     nsrefcnt               mRef;
     nsCString              mHashKey;
     nsCString              mHost;
     PRInt32                mPort;
--- a/netwerk/protocol/http/nsHttpConnectionMgr.cpp
+++ b/netwerk/protocol/http/nsHttpConnectionMgr.cpp
@@ -138,32 +138,30 @@ nsHttpConnectionMgr::EnsureSocketThreadT
 
 nsresult
 nsHttpConnectionMgr::Init(PRUint16 maxConns,
                           PRUint16 maxConnsPerHost,
                           PRUint16 maxConnsPerProxy,
                           PRUint16 maxPersistConnsPerHost,
                           PRUint16 maxPersistConnsPerProxy,
                           PRUint16 maxRequestDelay,
-                          PRUint16 maxPipelinedRequests,
-                          PRUint16 maxOptimisticPipelinedRequests)
+                          PRUint16 maxPipelinedRequests)
 {
     LOG(("nsHttpConnectionMgr::Init\n"));
 
     {
         ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 
         mMaxConns = maxConns;
         mMaxConnsPerHost = maxConnsPerHost;
         mMaxConnsPerProxy = maxConnsPerProxy;
         mMaxPersistConnsPerHost = maxPersistConnsPerHost;
         mMaxPersistConnsPerProxy = maxPersistConnsPerProxy;
         mMaxRequestDelay = maxRequestDelay;
         mMaxPipelinedRequests = maxPipelinedRequests;
-        mMaxOptimisticPipelinedRequests = maxOptimisticPipelinedRequests;
 
         mIsShuttingDown = false;
     }
 
     return EnsureSocketThreadTargetIfOnline();
 }
 
 nsresult
@@ -208,17 +206,20 @@ nsHttpConnectionMgr::PostEvent(nsConnEve
 
     nsresult rv;
     if (!mSocketThreadTarget) {
         NS_WARNING("cannot post event if not initialized");
         rv = NS_ERROR_NOT_INITIALIZED;
     }
     else {
         nsRefPtr<nsIRunnable> event = new nsConnEvent(this, handler, iparam, vparam);
-        rv = mSocketThreadTarget->Dispatch(event, NS_DISPATCH_NORMAL);
+        if (!event)
+            rv = NS_ERROR_OUT_OF_MEMORY;
+        else
+            rv = mSocketThreadTarget->Dispatch(event, NS_DISPATCH_NORMAL);
     }
     return rv;
 }
 
 void
 nsHttpConnectionMgr::PruneDeadConnectionsAfter(PRUint32 timeInSeconds)
 {
     LOG(("nsHttpConnectionMgr::PruneDeadConnectionsAfter\n"));
@@ -343,16 +344,45 @@ nsHttpConnectionMgr::GetSocketThreadTarg
     // care of initializing the socket thread target if that's the case.
     EnsureSocketThreadTargetIfOnline();
 
     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
     NS_IF_ADDREF(*target = mSocketThreadTarget);
     return NS_OK;
 }
 
+void
+nsHttpConnectionMgr::AddTransactionToPipeline(nsHttpPipeline *pipeline)
+{
+    LOG(("nsHttpConnectionMgr::AddTransactionToPipeline [pipeline=%x]\n", pipeline));
+
+    NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
+
+    nsRefPtr<nsHttpConnectionInfo> ci;
+    pipeline->GetConnectionInfo(getter_AddRefs(ci));
+    if (ci) {
+        nsConnectionEntry *ent = mCT.Get(ci->HashKey());
+        if (ent) {
+            // search for another request to pipeline...
+            PRInt32 i, count = ent->mPendingQ.Length();
+            for (i=0; i<count; ++i) {
+                nsHttpTransaction *trans = ent->mPendingQ[i];
+                if (trans->Caps() & NS_HTTP_ALLOW_PIPELINING) {
+                    pipeline->AddTransaction(trans);
+
+                    // remove transaction from pending queue
+                    ent->mPendingQ.RemoveElementAt(i);
+                    NS_RELEASE(trans);
+                    break;
+                }
+            }
+        }
+    }
+}
+
 nsresult
 nsHttpConnectionMgr::ReclaimConnection(nsHttpConnection *conn)
 {
     LOG(("nsHttpConnectionMgr::ReclaimConnection [conn=%x]\n", conn));
 
     NS_ADDREF(conn);
     nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgReclaimConnection, 0, conn);
     if (NS_FAILED(rv))
@@ -775,35 +805,39 @@ nsHttpConnectionMgr::PruneDeadConnection
         // mTimeOfNextWakeUp, we need to schedule the pruning to happen
         // after timeToNextExpire.
         if (!self->mTimer || timeOfNextExpire < self->mTimeOfNextWakeUp) {
             self->PruneDeadConnectionsAfter(timeToNextExpire);
         }
     } else {
         self->ConditionallyStopPruneDeadConnectionsTimer();
     }
+#ifdef DEBUG
+    count = ent->mActiveConns.Length();
+    if (count > 0) {
+        for (PRInt32 i=count-1; i>=0; --i) {
+            nsHttpConnection *conn = ent->mActiveConns[i];
+            LOG(("    active conn [%x] with trans [%x]\n", conn, conn->Transaction()));
+        }
+    }
+#endif
 
-    // if this entry is empty, we have too many entries,
-    // and this doesn't represent some painfully determined
-    // red condition, then we can clean it up and restart from
-    // yellow
-    if (ent->PipelineState()       != PS_RED &&
-        self->mCT.Count()          >  125 &&
-        ent->mIdleConns.Length()   == 0 &&
+    // if this entry is empty, then we can remove it.
+    if (ent->mIdleConns.Length()   == 0 &&
         ent->mActiveConns.Length() == 0 &&
         ent->mHalfOpens.Length()   == 0 &&
         ent->mPendingQ.Length()    == 0 &&
         ((!ent->mTestedSpdy && !ent->mUsingSpdy) ||
          !gHttpHandler->IsSpdyEnabled() ||
          self->mCT.Count() > 300)) {
         LOG(("    removing empty connection entry\n"));
         return PL_DHASH_REMOVE;
     }
 
-    // otherwise use this opportunity to compact our arrays...
+    // else, use this opportunity to compact our arrays...
     ent->mIdleConns.Compact();
     ent->mActiveConns.Compact();
     ent->mPendingQ.Compact();
 
     return PL_DHASH_NEXT;
 }
 
 PLDHashOperator
@@ -859,165 +893,74 @@ nsHttpConnectionMgr::ShutdownPassCB(cons
 }
 
 //-----------------------------------------------------------------------------
 
 bool
 nsHttpConnectionMgr::ProcessPendingQForEntry(nsConnectionEntry *ent)
 {
     NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
-
     LOG(("nsHttpConnectionMgr::ProcessPendingQForEntry [ci=%s]\n",
-         ent->mConnInfo->HashKey().get()));
+        ent->mConnInfo->HashKey().get()));
 
     ProcessSpdyPendingQ(ent);
 
-    PRUint32 count = ent->mPendingQ.Length();
-    nsHttpTransaction *trans;
-    nsresult rv;
-    bool dispatchedSuccessfully = false;
-
-    // iterate the pending list until one is dispatched successfully. Keep
-    // iterating afterwards only until a transaction fails to dispatch.
-    for (PRUint32 i = 0; i < count; ++i) {
-        trans = ent->mPendingQ[i];
+    PRUint32 i, count = ent->mPendingQ.Length();
+    if (count > 0) {
+        LOG(("  pending-count=%u\n", count));
+        nsHttpTransaction *trans = nsnull;
+        nsHttpConnection *conn = nsnull;
+        for (i = 0; i < count; ++i) {
+            trans = ent->mPendingQ[i];
 
-        // When this transaction has already established a half-open
-        // connection, we want to prevent any duplicate half-open
-        // connections from being established and bound to this
-        // transaction. Allow only use of an idle persistent connection
-        // (if found) for transactions referred by a half-open connection.
-        bool alreadyHalfOpen = false;
-        for (PRInt32 j = 0; j < ((PRInt32) ent->mHalfOpens.Length()); ++j) {
-            if (ent->mHalfOpens[j]->Transaction() == trans) {
-                alreadyHalfOpen = true;
-                break;
+            // When this transaction has already established a half-open
+            // connection, we want to prevent any duplicate half-open
+            // connections from being established and bound to this
+            // transaction. Allow only use of an idle persistent connection
+            // (if found) for transactions referred by a half-open connection.
+            bool alreadyHalfOpen = false;
+            for (PRInt32 j = 0; j < ((PRInt32) ent->mHalfOpens.Length()); j++) {
+                if (ent->mHalfOpens[j]->Transaction() == trans) {
+                    alreadyHalfOpen = true;
+                    break;
+                }
             }
-        }
+
+            GetConnection(ent, trans, alreadyHalfOpen, &conn);
+            if (conn)
+                break;
 
-        rv = TryDispatchTransaction(ent, alreadyHalfOpen, trans);
-        if (NS_SUCCEEDED(rv)) {
+            NS_ABORT_IF_FALSE(count == ent->mPendingQ.Length(),
+                              "something mutated pending queue from "
+                              "GetConnection()");
+        }
+        if (conn) {
             LOG(("  dispatching pending transaction...\n"));
+
+            // remove pending transaction
             ent->mPendingQ.RemoveElementAt(i);
-            NS_RELEASE(trans);
 
-            // reset index and array length after RemoveElelmentAt()
-            dispatchedSuccessfully = true;
-            count = ent->mPendingQ.Length();
-            --i;
-            continue;
-        }
+            nsresult rv = DispatchTransaction(ent, trans, trans->Caps(), conn);
+            if (NS_SUCCEEDED(rv))
+                NS_RELEASE(trans);
+            else {
+                LOG(("  DispatchTransaction failed [rv=%x]\n", rv));
+                // on failure, just put the transaction back
+                ent->mPendingQ.InsertElementAt(i, trans);
+                // might be something wrong with the connection... close it.
+                conn->Close(rv);
+            }
 
-        if (dispatchedSuccessfully)
+            NS_RELEASE(conn);
             return true;
-
-        NS_ABORT_IF_FALSE(count == ((PRInt32) ent->mPendingQ.Length()),
-                          "something mutated pending queue from "
-                          "GetConnection()");
+        }
     }
     return false;
 }
 
-bool
-nsHttpConnectionMgr::ProcessPendingQForEntry(nsHttpConnectionInfo *ci)
-{
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
-
-    nsConnectionEntry *ent = mCT.Get(ci->HashKey());
-    if (ent)
-        return ProcessPendingQForEntry(ent);
-    return false;
-}
-
-bool
-nsHttpConnectionMgr::SupportsPipelining(nsHttpConnectionInfo *ci)
-{
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
-
-    nsConnectionEntry *ent = mCT.Get(ci->HashKey());
-    if (ent)
-        return ent->SupportsPipelining();
-    return false;
-}
-
-// nsHttpPipelineFeedback used to hold references across events
-
-class nsHttpPipelineFeedback
-{
-public:
-    nsHttpPipelineFeedback(nsHttpConnectionInfo *ci,
-                           nsHttpConnectionMgr::PipelineFeedbackInfoType info,
-                           nsHttpConnection *conn, PRUint32 data)
-        : mConnInfo(ci)
-        , mConn(conn)
-        , mInfo(info)
-        , mData(data)
-        {
-        }
-    
-    ~nsHttpPipelineFeedback()
-    {
-    }
-    
-    nsRefPtr<nsHttpConnectionInfo> mConnInfo;
-    nsRefPtr<nsHttpConnection> mConn;
-    nsHttpConnectionMgr::PipelineFeedbackInfoType mInfo;
-    PRUint32 mData;
-};
-
-void
-nsHttpConnectionMgr::PipelineFeedbackInfo(nsHttpConnectionInfo *ci,
-                                          PipelineFeedbackInfoType info,
-                                          nsHttpConnection *conn,
-                                          PRUint32 data)
-{
-    if (!ci)
-        return;
-
-    // Post this to the socket thread if we are not running there already
-    if (PR_GetCurrentThread() != gSocketThread) {
-        nsHttpPipelineFeedback *fb = new nsHttpPipelineFeedback(ci, info,
-                                                                conn, data);
-
-        nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgProcessFeedback,
-                                0, fb);
-        if (NS_FAILED(rv))
-            delete fb;
-        return;
-    }
-
-    nsConnectionEntry *ent = mCT.Get(ci->HashKey());
-
-    if (ent)
-        ent->OnPipelineFeedbackInfo(info, conn, data);
-}
-
-void
-nsHttpConnectionMgr::ReportFailedToProcess(nsIURI *uri)
-{
-    NS_ABORT_IF_FALSE(uri, "precondition");
-
-    nsCAutoString host;
-    PRInt32 port = -1;
-    bool usingSSL = false;
-
-    nsresult rv = uri->SchemeIs("https", &usingSSL);
-    if (NS_SUCCEEDED(rv))
-        rv = uri->GetAsciiHost(host);
-    if (NS_SUCCEEDED(rv))
-        rv = uri->GetPort(&port);
-    if (NS_FAILED(rv) || host.IsEmpty())
-        return;
-
-    nsRefPtr<nsHttpConnectionInfo> ci =
-        new nsHttpConnectionInfo(host, port, nsnull, usingSSL);
-    
-    PipelineFeedbackInfo(ci, RedCorruptedContent, nsnull, 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, PRUint8 caps)
 {
     nsHttpConnectionInfo *ci = ent->mConnInfo;
@@ -1101,468 +1044,132 @@ nsHttpConnectionMgr::ClosePersistentConn
                                                   nsAutoPtr<nsConnectionEntry> &ent,
                                                   void *closure)
 {
     nsHttpConnectionMgr *self = static_cast<nsHttpConnectionMgr *>(closure);
     self->ClosePersistentConnections(ent);
     return PL_DHASH_NEXT;
 }
 
-bool
-nsHttpConnectionMgr::MakeNewConnection(nsConnectionEntry *ent,
-                                       nsHttpTransaction *trans)
+void
+nsHttpConnectionMgr::GetConnection(nsConnectionEntry *ent,
+                                   nsHttpTransaction *trans,
+                                   bool onlyReusedConnection,
+                                   nsHttpConnection **result)
 {
-    LOG(("nsHttpConnectionMgr::MakeNewConnection %p ent=%p trans=%p",
-         this, ent, trans));
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
-        
-    // If this host is trying to negotiate a SPDY session right now,
-    // don't create any new connections until the result of the
-    // negotiation is known.
-
-    if (gHttpHandler->IsSpdyEnabled() &&
-        ent->mConnInfo->UsingSSL() &&
-        !ent->mConnInfo->UsingHttpProxy() &&
-        !(trans->Caps() & NS_HTTP_DISALLOW_SPDY) &&
-        (!ent->mTestedSpdy || ent->mUsingSpdy) &&
-        (ent->mHalfOpens.Length() || ent->mActiveConns.Length())) {
-        return false;
-    }
-
-    // We need to make a new connection. If that is going to exceed the
-    // global connection limit then try and free up some room by closing
-    // an idle connection to another host. We know it won't select "ent"
-    // beacuse we have already determined there are no idle connections
-    // to our destination
-
-    if ((mNumIdleConns + mNumActiveConns + 1 >= mMaxConns) && mNumIdleConns)
-        mCT.Enumerate(PurgeExcessIdleConnectionsCB, this);
-
-    if (AtActiveConnectionLimit(ent, trans->Caps()))
-        return false;
-
-    nsresult rv = CreateTransport(ent, trans);
-    if (NS_FAILED(rv))                            /* hard failure */
-        trans->Close(rv);
-
-    return true;
-}
-
-bool
-nsHttpConnectionMgr::AddToShortestPipeline(nsConnectionEntry *ent,
-                                           nsHttpTransaction *trans,
-                                           nsHttpTransaction::Classifier classification,
-                                           PRUint16 depthLimit)
-{
-    if (classification == nsAHttpTransaction::CLASS_SOLO)
-        return false;
+    LOG(("nsHttpConnectionMgr::GetConnection [ci=%s caps=%x]\n",
+        ent->mConnInfo->HashKey().get(), PRUint32(trans->Caps())));
 
-    PRUint32 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 = PR_MIN(maxdepth, depthLimit);
-
-    if (maxdepth < 2)
-        return false;
-
-    nsAHttpTransaction *activeTrans;
+    // First, see if an existing connection can be used - either an idle
+    // persistent connection or an active spdy session may be reused instead of
+    // establishing a new socket. We do not need to check the connection limits
+    // yet as they govern the maximum number of open connections and reusing
+    // an old connection never increases that.
 
-    nsHttpConnection *bestConn = nsnull;
-    PRUint32 activeCount = ent->mActiveConns.Length();
-    PRUint32 bestConnLength = 0;
-    PRUint32 connLength;
-
-    for (PRUint32 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;
+    *result = nsnull;
 
-    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);
-    return true;
-}
+    nsHttpConnection *conn = nsnull;
+    bool addConnToActiveList = 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 defintion 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.
-    
-    PRInt32 currentConns = ent->mActiveConns.Length();
-    PRInt32 maxConns =
-        (ent->mConnInfo->UsingHttpProxy() && !ent->mConnInfo->UsingSSL()) ?
-        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 */
-
-    PRInt32 sameClass = 0;
-    for (PRInt32 i = 0; i < currentConns; ++i)
-        if (classification == ent->mActiveConns[i]->Classification())
-            if (++sameClass == 3)
-                return true;                   /* prefer pipeline */
-    
-    return false;                              /* normal behavior */
-}
+    if (trans->Caps() & NS_HTTP_ALLOW_KEEPALIVE) {
 
-// 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
-nsresult
-nsHttpConnectionMgr::TryDispatchTransaction(nsConnectionEntry *ent,
-                                            bool onlyReusedConnection,
-                                            nsHttpTransaction *trans)
-{
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
-    LOG(("nsHttpConnectionMgr::TryDispatchTransaction without conn "
-         "[ci=%s caps=%x]\n",
-         ent->mConnInfo->HashKey().get(), PRUint32(trans->Caps())));
-
-    nsHttpTransaction::Classifier classification = trans->Classification();
-    PRUint8 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);
-
-    // step 0
-    // look for existing spdy connection - that's always best because it is
-    // essentially pipelining without head of line blocking
-
-    if (!(caps & NS_HTTP_DISALLOW_SPDY) && gHttpHandler->IsSpdyEnabled()) {
-        nsRefPtr<nsHttpConnection> conn = GetSpdyPreferredConn(ent);
-        if (conn) {
-            LOG(("   dispatch to spdy: [conn=%x]\n", conn.get()));
-            DispatchTransaction(ent, trans, conn);
-            return NS_OK;
+        // if willing to use spdy look for an active spdy connections
+        // before considering idle http ones.
+        if (gHttpHandler->IsSpdyEnabled()) {
+            conn = GetSpdyPreferredConn(ent);
+            if (conn)
+                addConnToActiveList = false;
         }
-    }
-
-    // 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)) {
-            return NS_OK;
-        }
-    }
-
-    // step 2
-    // consider an idle persistent connection
-    if (caps & NS_HTTP_ALLOW_KEEPALIVE) {
-        nsRefPtr<nsHttpConnection> conn;
+        
+        // search the idle connection list. Each element in the list
+        // has a reference, so if we remove it from the list into a local
+        // ptr, that ptr now owns the reference
         while (!conn && (ent->mIdleConns.Length() > 0)) {
             conn = ent->mIdleConns[0];
-            ent->mIdleConns.RemoveElementAt(0);
-            mNumIdleConns--;
-            nsHttpConnection *temp = conn;
-            NS_RELEASE(temp);
-            
             // we check if the connection can be reused before even checking if
             // it is a "matching" connection.
             if (!conn->CanReuse()) {
-                LOG(("   dropping stale connection: [conn=%x]\n", conn.get()));
+                LOG(("   dropping stale connection: [conn=%x]\n", conn));
                 conn->Close(NS_ERROR_ABORT);
-                conn = nsnull;
+                NS_RELEASE(conn);
             }
             else {
-                LOG(("   reusing connection [conn=%x]\n", conn.get()));
+                LOG(("   reusing connection [conn=%x]\n", conn));
                 conn->EndIdleMonitoring();
             }
 
+            ent->mIdleConns.RemoveElementAt(0);
+            mNumIdleConns--;
+
             // If there are no idle connections left at all, we need to make
             // sure that we are not pruning dead connections anymore.
             ConditionallyStopPruneDeadConnectionsTimer();
         }
-        if (conn) {
-            // This will update the class of the connection to be the class of
-            // the transaction dispatched on it.
-            AddActiveConn(conn, ent);
-            DispatchTransaction(ent, trans, conn);
-            return NS_OK;
-        }
-    }
-
-    // step 3
-    // consider pipelining scripts and revalidations
-    if (!attemptedOptimisticPipeline &&
-        (classification == nsHttpTransaction::CLASS_REVALIDATION ||
-         classification == nsHttpTransaction::CLASS_SCRIPT)) {
-        attemptedOptimisticPipeline = true;
-        if (AddToShortestPipeline(ent, trans,
-                                  classification,
-                                  mMaxOptimisticPipelinedRequests)) {
-            return NS_OK;
-        }
-    }
-
-    // step 4
-    if (!onlyReusedConnection && MakeNewConnection(ent, trans)) {
-        return NS_ERROR_IN_PROGRESS;
-    }
-    
-    // step 5
-    if (caps & NS_HTTP_ALLOW_PIPELINING) {
-        if (AddToShortestPipeline(ent, trans,
-                                  classification,
-                                  mMaxPipelinedRequests)) {
-            return NS_OK;
-        }
-    }
-    
-    // step 6
-    return NS_ERROR_NOT_AVAILABLE;                /* queue it */
-}
-
-nsresult
-nsHttpConnectionMgr::DispatchTransaction(nsConnectionEntry *ent,
-                                         nsHttpTransaction *trans,
-                                         nsHttpConnection *conn)
-{
-    PRUint8 caps = trans->Caps();
-    PRInt32 priority = trans->Priority();
-
-    LOG(("nsHttpConnectionMgr::DispatchTransaction "
-         "[ci=%s trans=%x caps=%x conn=%x priority=%d]\n",
-         ent->mConnInfo->HashKey().get(), trans, caps, conn, priority));
-
-    if (conn->UsingSpdy()) {
-        LOG(("Spdy Dispatch Transaction via Activate(). Transaction host = %s,"
-             "Connection host = %s\n",
-             trans->ConnectionInfo()->Host(),
-             conn->ConnectionInfo()->Host()));
-        nsresult rv = conn->Activate(trans, caps, priority);
-        NS_ABORT_IF_FALSE(NS_SUCCEEDED(rv), "SPDY Cannot Fail Dispatch");
-        return rv;
-    }
-
-    NS_ABORT_IF_FALSE(conn && !conn->Transaction(),
-                      "DispatchTranaction() on non spdy active connection");
-
-    /* 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 */
-
-    nsRefPtr<nsHttpPipeline> pipeline;
-    nsresult rv = BuildPipeline(ent, trans, getter_AddRefs(pipeline));
-    if (!NS_SUCCEEDED(rv))
-        return rv;
-
-    nsRefPtr<nsConnectionHandle> handle = new nsConnectionHandle(conn);
-
-    // give the transaction the indirect reference to the connection.
-    pipeline->SetConnection(handle);
-
-    if (!(caps & NS_HTTP_ALLOW_PIPELINING))
-        conn->Classify(nsAHttpTransaction::CLASS_SOLO);
-    else
-        conn->Classify(trans->Classification());
-
-    rv = conn->Activate(pipeline, caps, priority);
-    if (NS_FAILED(rv)) {
-        LOG(("  conn->Activate failed [rv=%x]\n", rv));
-        ent->mActiveConns.RemoveElement(conn);
-        if (conn == ent->mYellowConnection)
-            ent->OnYellowComplete();
-        mNumActiveConns--;
-        // sever back references to connection, and do so without triggering
-        // a call to ReclaimConnection ;-)
-        pipeline->SetConnection(nsnull);
-        NS_RELEASE(handle->mConn);
-        // destroy the connection
-        NS_RELEASE(conn);
     }
 
-    // As pipeline 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)
-{
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
-
-    /* form a pipeline here even if nothing is pending so that we
-       can stream-feed it as new transactions arrive */
+    if (!conn) {
 
-    /* the first transaction can go in unconditionally - 1 transaction
-       on a nsHttpPipeline object is not a real HTTP pipeline */
-   
-    nsRefPtr<nsHttpPipeline> pipeline = new nsHttpPipeline();
-    pipeline->AddTransaction(firstTrans);
-    NS_ADDREF(*result = pipeline);
-    return NS_OK;
-}
+        // If the onlyReusedConnection parameter is TRUE, then GetConnection()
+        // does not create new transports under any circumstances.
+        if (onlyReusedConnection)
+            return;
+        
+        if (gHttpHandler->IsSpdyEnabled() &&
+            ent->mConnInfo->UsingSSL() &&
+            !ent->mConnInfo->UsingHttpProxy())
+        {
+            // If this host is trying to negotiate a SPDY session right now,
+            // don't create any new connections until the result of the
+            // negotiation is known.
+    
+            if ((!ent->mTestedSpdy || ent->mUsingSpdy) &&
+                (ent->mHalfOpens.Length() || ent->mActiveConns.Length()))
+                return;
+        }
+        
+        // Check if we need to purge an idle connection. Note that we may have
+        // removed one above; if so, this will be a no-op. We do this before
+        // checking the active connection limit to catch the case where we do
+        // have an idle connection, but the purge timer hasn't fired yet.
+        // XXX this just purges a random idle connection.  we should instead
+        // enumerate the entire hash table to find the eldest idle connection.
+        if (mNumIdleConns && mNumIdleConns + mNumActiveConns + 1 >= mMaxConns)
+            mCT.Enumerate(PurgeExcessIdleConnectionsCB, this);
 
-nsresult
-nsHttpConnectionMgr::ProcessNewTransaction(nsHttpTransaction *trans)
-{
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
+        // Need to make a new TCP connection. First, we check if we've hit
+        // either the maximum connection limit globally or for this particular
+        // host or proxy. If we have, we're done.
+        if (AtActiveConnectionLimit(ent, trans->Caps())) {
+            LOG(("nsHttpConnectionMgr::GetConnection [ci = %s]"
+                 "at active connection limit - will queue\n",
+                 ent->mConnInfo->HashKey().get()));
+            return;
+        }
 
-    // since "adds" and "cancels" are processed asynchronously and because
-    // various events might trigger an "add" directly on the socket thread,
-    // we must take care to avoid dispatching a transaction that has already
-    // been canceled (see bug 190001).
-    if (NS_FAILED(trans->Status())) {
-        LOG(("  transaction was canceled... dropping event!\n"));
-        return NS_OK;
+        LOG(("nsHttpConnectionMgr::GetConnection Open Connection "
+             "%s %s ent=%p spdy=%d",
+             ent->mConnInfo->Host(), ent->mCoalescingKey.get(),
+             ent, ent->mUsingSpdy));
+        
+        nsresult rv = CreateTransport(ent, trans);
+        if (NS_FAILED(rv))
+            trans->Close(rv);
+        return;
     }
 
-    nsresult rv = NS_OK;
-    nsHttpConnectionInfo *ci = trans->ConnectionInfo();
-    NS_ASSERTION(ci, "no connection info");
-
-    nsConnectionEntry *ent = mCT.Get(ci->HashKey());
-    if (!ent) {
-        nsHttpConnectionInfo *clone = ci->Clone();
-        if (!clone)
-            return NS_ERROR_OUT_OF_MEMORY;
-        ent = new nsConnectionEntry(clone);
-        mCT.Put(ci->HashKey(), ent);
-    }
-
-    // SPDY coalescing of hostnames means we might redirect from this
-    // connection entry onto the preferred one.
-    nsConnectionEntry *preferredEntry = GetSpdyPreferredEnt(ent);
-    if (preferredEntry && (preferredEntry != ent)) {
-        LOG(("nsHttpConnectionMgr::ProcessNewTransaction trans=%p "
-             "redirected via coalescing from %s to %s\n", trans,
-             ent->mConnInfo->Host(), preferredEntry->mConnInfo->Host()));
-
-        ent = preferredEntry;
+    if (addConnToActiveList) {
+        // hold an owning ref to this connection
+        ent->mActiveConns.AppendElement(conn);
+        mNumActiveConns++;
     }
-
-    // If we are doing a force reload then close out any existing conns
-    // to this host so that changes in DNS, LBs, etc.. are reflected
-    if (trans->Caps() & NS_HTTP_CLEAR_KEEPALIVES)
-        ClosePersistentConnections(ent);
-
-    // Check if the transaction already has a sticky reference to a connection.
-    // If so, then we can just use it directly by transferring its reference
-    // to the new connection variable instead of searching for a new one
-
-    nsAHttpConnection *wrappedConnection = trans->Connection();
-    nsRefPtr<nsHttpConnection> conn;
-    if (wrappedConnection)
-        conn = dont_AddRef(wrappedConnection->TakeHttpConnection());
-
-    if (conn) {
-        NS_ASSERTION(trans->Caps() & NS_HTTP_STICKY_CONNECTION,
-                     "unexpected caps");
-        NS_ABORT_IF_FALSE(((PRInt32)ent->mActiveConns.IndexOf(conn)) != -1,
-                          "Sticky Connection Not In Active List");
-        trans->SetConnection(nsnull);
-        rv = DispatchTransaction(ent, trans, conn);
-    }
-    else
-        rv = TryDispatchTransaction(ent, false, trans);
-
-    if (NS_FAILED(rv)) {
-        LOG(("  adding transaction to pending queue "
-             "[trans=%p pending-count=%u]\n",
-             trans, ent->mPendingQ.Length()+1));
-        // put this transaction on the pending queue...
-        InsertTransactionSorted(ent->mPendingQ, trans);
-        NS_ADDREF(trans);
-    }
-
-    return NS_OK;
+    
+    NS_ADDREF(conn);
+    *result = conn;
 }
 
-
 void
 nsHttpConnectionMgr::AddActiveConn(nsHttpConnection *conn,
                                    nsConnectionEntry *ent)
 {
     NS_ADDREF(conn);
     ent->mActiveConns.AppendElement(conn);
     mNumActiveConns++;
     ActivateTimeoutTick();
@@ -1589,16 +1196,200 @@ nsHttpConnectionMgr::CreateTransport(nsC
     nsRefPtr<nsHalfOpenSocket> sock = new nsHalfOpenSocket(ent, trans);
     nsresult rv = sock->SetupPrimaryStreams();
     NS_ENSURE_SUCCESS(rv, rv);
 
     ent->mHalfOpens.AppendElement(sock);
     return NS_OK;
 }
 
+nsresult
+nsHttpConnectionMgr::DispatchTransaction(nsConnectionEntry *ent,
+                                         nsHttpTransaction *aTrans,
+                                         PRUint8 caps,
+                                         nsHttpConnection *conn)
+{
+    LOG(("nsHttpConnectionMgr::DispatchTransaction [ci=%s trans=%x caps=%x conn=%x]\n",
+        ent->mConnInfo->HashKey().get(), aTrans, caps, conn));
+    nsresult rv;
+    
+    PRInt32 priority = aTrans->Priority();
+
+    if (conn->UsingSpdy()) {
+        LOG(("Spdy Dispatch Transaction via Activate(). Transaction host = %s,"
+             "Connection host = %s\n",
+             aTrans->ConnectionInfo()->Host(),
+             conn->ConnectionInfo()->Host()));
+        rv = conn->Activate(aTrans, caps, priority);
+        NS_ABORT_IF_FALSE(NS_SUCCEEDED(rv), "SPDY Cannot Fail Dispatch");
+        return rv;
+    }
+
+    nsConnectionHandle *handle = new nsConnectionHandle(conn);
+    if (!handle)
+        return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(handle);
+
+    nsHttpPipeline *pipeline = nsnull;
+    nsAHttpTransaction *trans = aTrans;
+
+    if (conn->SupportsPipelining() && (caps & NS_HTTP_ALLOW_PIPELINING)) {
+        LOG(("  looking to build pipeline...\n"));
+        if (BuildPipeline(ent, trans, &pipeline))
+            trans = pipeline;
+    }
+
+    // give the transaction the indirect reference to the connection.
+    trans->SetConnection(handle);
+
+    rv = conn->Activate(trans, caps, priority);
+
+    if (NS_FAILED(rv)) {
+        LOG(("  conn->Activate failed [rv=%x]\n", rv));
+        ent->mActiveConns.RemoveElement(conn);
+        mNumActiveConns--;
+        // sever back references to connection, and do so without triggering
+        // a call to ReclaimConnection ;-)
+        trans->SetConnection(nsnull);
+        NS_RELEASE(handle->mConn);
+        // destroy the connection
+        NS_RELEASE(conn);
+    }
+
+    // if we were unable to activate the pipeline, then this will destroy
+    // the pipeline, which will cause each the transactions owned by the 
+    // pipeline to be restarted.
+    NS_IF_RELEASE(pipeline);
+
+    NS_RELEASE(handle);
+    return rv;
+}
+
+bool
+nsHttpConnectionMgr::BuildPipeline(nsConnectionEntry *ent,
+                                   nsAHttpTransaction *firstTrans,
+                                   nsHttpPipeline **result)
+{
+    if (mMaxPipelinedRequests < 2)
+        return false;
+
+    nsHttpPipeline *pipeline = nsnull;
+    nsHttpTransaction *trans;
+
+    PRUint32 i = 0, numAdded = 0;
+    while (i < ent->mPendingQ.Length()) {
+        trans = ent->mPendingQ[i];
+        if (trans->Caps() & NS_HTTP_ALLOW_PIPELINING) {
+            if (numAdded == 0) {
+                pipeline = new nsHttpPipeline;
+                if (!pipeline)
+                    return false;
+                pipeline->AddTransaction(firstTrans);
+                numAdded = 1;
+            }
+            pipeline->AddTransaction(trans);
+
+            // remove transaction from pending queue
+            ent->mPendingQ.RemoveElementAt(i);
+            NS_RELEASE(trans);
+
+            if (++numAdded == mMaxPipelinedRequests)
+                break;
+        }
+        else
+            ++i; // skip to next pending transaction
+    }
+
+    if (numAdded == 0)
+        return false;
+
+    LOG(("  pipelined %u transactions\n", numAdded));
+    NS_ADDREF(*result = pipeline);
+    return true;
+}
+
+nsresult
+nsHttpConnectionMgr::ProcessNewTransaction(nsHttpTransaction *trans)
+{
+    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
+
+    // since "adds" and "cancels" are processed asynchronously and because
+    // various events might trigger an "add" directly on the socket thread,
+    // we must take care to avoid dispatching a transaction that has already
+    // been canceled (see bug 190001).
+    if (NS_FAILED(trans->Status())) {
+        LOG(("  transaction was canceled... dropping event!\n"));
+        return NS_OK;
+    }
+
+    PRUint8 caps = trans->Caps();
+    nsHttpConnectionInfo *ci = trans->ConnectionInfo();
+    NS_ASSERTION(ci, "no connection info");
+
+    nsConnectionEntry *ent = mCT.Get(ci->HashKey());
+    if (!ent) {
+        nsHttpConnectionInfo *clone = ci->Clone();
+        if (!clone)
+            return NS_ERROR_OUT_OF_MEMORY;
+        ent = new nsConnectionEntry(clone);
+        if (!ent)
+            return NS_ERROR_OUT_OF_MEMORY;
+        mCT.Put(ci->HashKey(), ent);
+    }
+
+    // SPDY coalescing of hostnames means we might redirect from this
+    // connection entry onto the preferred one.
+    nsConnectionEntry *preferredEntry = GetSpdyPreferredEnt(ent);
+    if (preferredEntry && (preferredEntry != ent)) {
+        LOG(("nsHttpConnectionMgr::ProcessNewTransaction trans=%p "
+             "redirected via coalescing from %s to %s\n", trans,
+             ent->mConnInfo->Host(), preferredEntry->mConnInfo->Host()));
+
+        ent = preferredEntry;
+    }
+
+    // If we are doing a force reload then close out any existing conns
+    // to this host so that changes in DNS, LBs, etc.. are reflected
+    if (caps & NS_HTTP_CLEAR_KEEPALIVES)
+        ClosePersistentConnections(ent);
+
+    // Check if the transaction already has a sticky reference to a connection.
+    // If so, then we can just use it directly by transferring its reference
+    // to the new connection var instead of calling GetConnection() to search
+    // for an available one.
+
+    nsAHttpConnection *wrappedConnection = trans->Connection();
+    nsHttpConnection  *conn;
+    conn = wrappedConnection ? wrappedConnection->TakeHttpConnection() : nsnull;
+
+    if (conn) {
+        NS_ASSERTION(caps & NS_HTTP_STICKY_CONNECTION, "unexpected caps");
+
+        trans->SetConnection(nsnull);
+    }
+    else
+        GetConnection(ent, trans, false, &conn);
+
+    nsresult rv;
+    if (!conn) {
+        LOG(("  adding transaction to pending queue [trans=%x pending-count=%u]\n",
+            trans, ent->mPendingQ.Length()+1));
+        // put this transaction on the pending queue...
+        InsertTransactionSorted(ent->mPendingQ, trans);
+        NS_ADDREF(trans);
+        rv = NS_OK;
+    }
+    else {
+        rv = DispatchTransaction(ent, trans, caps, conn);
+        NS_RELEASE(conn);
+    }
+
+    return rv;
+}
+
 // This function tries to dispatch the pending spdy transactions on
 // the connection entry sent in as an argument. It will do so on the
 // active spdy connection either in that same entry or in the
 // redirected 'preferred' entry for the same coalescing hash key if
 // coalescing is enabled.
 
 void
 nsHttpConnectionMgr::ProcessSpdyPendingQ(nsConnectionEntry *ent)
@@ -1613,17 +1404,17 @@ nsHttpConnectionMgr::ProcessSpdyPendingQ
         nsHttpTransaction *trans = ent->mPendingQ[index];
 
         if (!(trans->Caps() & NS_HTTP_ALLOW_KEEPALIVE) ||
             trans->Caps() & NS_HTTP_DISALLOW_SPDY)
             continue;
  
         ent->mPendingQ.RemoveElementAt(index);
 
-        nsresult rv = DispatchTransaction(ent, trans, conn);
+        nsresult rv = DispatchTransaction(ent, trans, trans->Caps(), conn);
         if (NS_FAILED(rv)) {
             // this cannot happen, but if due to some bug it does then
             // close the transaction
             NS_ABORT_IF_FALSE(false, "Dispatch SPDY Transaction");
             LOG(("ProcessSpdyPendingQ Dispatch Transaction failed trans=%p\n",
                     trans));
             trans->Close(rv);
         }
@@ -1678,17 +1469,16 @@ nsHttpConnectionMgr::GetSpdyPreferredCon
     return conn;
 }
 
 //-----------------------------------------------------------------------------
 
 void
 nsHttpConnectionMgr::OnMsgShutdown(PRInt32, void *)
 {
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
     LOG(("nsHttpConnectionMgr::OnMsgShutdown\n"));
 
     mCT.Enumerate(ShutdownPassCB, this);
 
     if (mReadTimeoutTick) {
         mReadTimeoutTick->Cancel();
         mReadTimeoutTick = nsnull;
         mReadTimeoutTickArmed = false;
@@ -1710,18 +1500,17 @@ nsHttpConnectionMgr::OnMsgNewTransaction
     if (NS_FAILED(rv))
         trans->Close(rv); // for whatever its worth
     NS_RELEASE(trans);
 }
 
 void
 nsHttpConnectionMgr::OnMsgReschedTransaction(PRInt32 priority, void *param)
 {
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
-    LOG(("nsHttpConnectionMgr::OnMsgReschedTransaction [trans=%p]\n", param));
+    LOG(("nsHttpConnectionMgr::OnMsgNewTransaction [trans=%p]\n", param));
 
     nsHttpTransaction *trans = (nsHttpTransaction *) param;
     trans->SetPriority(priority);
 
     nsConnectionEntry *ent = LookupConnectionEntry(trans->ConnectionInfo(),
                                                    nsnull, trans);
 
     if (ent) {
@@ -1733,17 +1522,16 @@ nsHttpConnectionMgr::OnMsgReschedTransac
     }
 
     NS_RELEASE(trans);
 }
 
 void
 nsHttpConnectionMgr::OnMsgCancelTransaction(PRInt32 reason, void *param)
 {
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
     LOG(("nsHttpConnectionMgr::OnMsgCancelTransaction [trans=%p]\n", param));
 
     nsHttpTransaction *trans = (nsHttpTransaction *) param;
     //
     // if the transaction owns a connection and the transaction is not done,
     // then ask the connection to close the transaction.  otherwise, close the
     // transaction directly (removing it from the pending queue first).
     //
@@ -1765,17 +1553,16 @@ nsHttpConnectionMgr::OnMsgCancelTransact
         trans->Close(reason);
     }
     NS_RELEASE(trans);
 }
 
 void
 nsHttpConnectionMgr::OnMsgProcessPendingQ(PRInt32, void *param)
 {
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
     nsHttpConnectionInfo *ci = (nsHttpConnectionInfo *) param;
 
     LOG(("nsHttpConnectionMgr::OnMsgProcessPendingQ [ci=%s]\n", ci->HashKey().get()));
 
     // start by processing the queue identified by the given connection info.
     nsConnectionEntry *ent = mCT.Get(ci->HashKey());
     if (!(ent && ProcessPendingQForEntry(ent))) {
         // if we reach here, it means that we couldn't dispatch a transaction
@@ -1784,17 +1571,16 @@ nsHttpConnectionMgr::OnMsgProcessPending
     }
 
     NS_RELEASE(ci);
 }
 
 void
 nsHttpConnectionMgr::OnMsgPruneDeadConnections(PRInt32, void *)
 {
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
     LOG(("nsHttpConnectionMgr::OnMsgPruneDeadConnections\n"));
 
     // Reset mTimeOfNextWakeUp so that we can find a new shortest value.
     mTimeOfNextWakeUp = LL_MAXUINT;
 
     // check canreuse() for all idle connections plus any active connections on
     // connection entries that are using spdy.
     if (mNumIdleConns || (mNumActiveConns && gHttpHandler->IsSpdyEnabled()))
@@ -1807,17 +1593,16 @@ nsHttpConnectionMgr::OnMsgClosePersisten
     LOG(("nsHttpConnectionMgr::OnMsgClosePersistentConnections\n"));
 
     mCT.Enumerate(ClosePersistentConnectionsCB, this);
 }
 
 void
 nsHttpConnectionMgr::OnMsgReclaimConnection(PRInt32, void *param)
 {
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
     LOG(("nsHttpConnectionMgr::OnMsgReclaimConnection [conn=%p]\n", param));
 
     nsHttpConnection *conn = (nsHttpConnection *) param;
 
     // 
     // 1) remove the connection from the active list
     // 2) if keep-alive, add connection to idle list
     // 3) post event to process the pending transaction queue
@@ -1847,18 +1632,16 @@ nsHttpConnectionMgr::OnMsgReclaimConnect
             // conns. Even when they have 0 transactions on them they are
             // considered active connections. So when one is reclaimed it
             // is really complete and is meant to be shut down and not
             // reused.
             conn->DontReuse();
         }
         
         if (ent->mActiveConns.RemoveElement(conn)) {
-            if (conn == ent->mYellowConnection)
-                ent->OnYellowComplete();
             nsHttpConnection *temp = conn;
             NS_RELEASE(temp);
             mNumActiveConns--;
         }
 
         if (conn->CanReuse()) {
             LOG(("  adding connection to idle list\n"));
             // Keep The idle connection list sorted with the connections that
@@ -1884,16 +1667,17 @@ nsHttpConnectionMgr::OnMsgReclaimConnect
             // time to live among the watched connections, pruning dead
             // connections needs to be done when it can't be reused anymore.
             PRUint32 timeToLive = conn->TimeToLive();
             if(!mTimer || NowInSeconds() + timeToLive < mTimeOfNextWakeUp)
                 PruneDeadConnectionsAfter(timeToLive);
         }
         else {
             LOG(("  connection cannot be reused; closing connection\n"));
+            // make sure the connection is closed and release our reference.
             conn->Close(NS_ERROR_ABORT);
         }
     }
  
     OnMsgProcessPendingQ(NS_OK, ci); // releases |ci|
     NS_RELEASE(conn);
 }
 
@@ -1920,52 +1704,45 @@ nsHttpConnectionMgr::OnMsgUpdateParam(PR
         mMaxPersistConnsPerProxy = value;
         break;
     case MAX_REQUEST_DELAY:
         mMaxRequestDelay = value;
         break;
     case MAX_PIPELINED_REQUESTS:
         mMaxPipelinedRequests = value;
         break;
-    case MAX_OPTIMISTIC_PIPELINED_REQUESTS:
-        mMaxOptimisticPipelinedRequests = value;
-        break;
     default:
         NS_NOTREACHED("unexpected parameter name");
     }
 }
 
 // nsHttpConnectionMgr::nsConnectionEntry
 nsHttpConnectionMgr::nsConnectionEntry::~nsConnectionEntry()
 {
     if (mSpdyPreferred)
         gHttpHandler->ConnMgr()->RemoveSpdyPreferredEnt(mCoalescingKey);
 
     NS_RELEASE(mConnInfo);
 }
 
-void
-nsHttpConnectionMgr::OnMsgProcessFeedback(PRInt32, void *param)
-{
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
-    nsHttpPipelineFeedback *fb = (nsHttpPipelineFeedback *)param;
-    
-    PipelineFeedbackInfo(fb->mConnInfo, fb->mInfo, fb->mConn, fb->mData);
-    delete fb;
-}
-
 // Read Timeout Tick handlers
 
 void
 nsHttpConnectionMgr::ActivateTimeoutTick()
 {
     NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
     LOG(("nsHttpConnectionMgr::ActivateTimeoutTick() "
          "this=%p mReadTimeoutTick=%p\n"));
 
+    // right now the spdy timeout code is the only thing hooked to the timeout
+    // tick, so disable it if spdy is not being used. However pipelining code
+    // will also want this functionality soon.
+    if (!gHttpHandler->IsSpdyEnabled())
+        return;
+
     // The timer tick should be enabled if it is not already pending.
     // Upon running the tick will rearm itself if there are active
     // connections available.
 
     if (mReadTimeoutTick && mReadTimeoutTickArmed)
         return;
 
     if (!mReadTimeoutTick) {
@@ -1973,17 +1750,18 @@ nsHttpConnectionMgr::ActivateTimeoutTick
         if (!mReadTimeoutTick) {
             NS_WARNING("failed to create timer for http timeout management");
             return;
         }
     }
 
     NS_ABORT_IF_FALSE(!mReadTimeoutTickArmed, "timer tick armed");
     mReadTimeoutTickArmed = true;
-    mReadTimeoutTick->Init(this, 1000, nsITimer::TYPE_REPEATING_SLACK);
+    // pipeline will expect a 1000ms granuality
+    mReadTimeoutTick->Init(this, 15000, nsITimer::TYPE_REPEATING_SLACK);
 }
 
 void
 nsHttpConnectionMgr::ReadTimeoutTick()
 {
     NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
     NS_ABORT_IF_FALSE(mReadTimeoutTick, "no readtimeout tick");
 
@@ -2084,22 +1862,16 @@ nsHttpConnectionMgr::nsConnectionHandle:
 }
 
 bool
 nsHttpConnectionMgr::nsConnectionHandle::IsReused()
 {
     return mConn->IsReused();
 }
 
-void
-nsHttpConnectionMgr::nsConnectionHandle::DontReuse()
-{
-    mConn->DontReuse();
-}
-
 nsresult
 nsHttpConnectionMgr::nsConnectionHandle::PushBack(const char *buf, PRUint32 bufLen)
 {
     return mConn->PushBack(buf, bufLen);
 }
 
 
 //////////////////////// nsHalfOpenSocket
@@ -2214,17 +1986,16 @@ nsHalfOpenSocket::SetupStreams(nsISocket
 
 nsresult
 nsHttpConnectionMgr::nsHalfOpenSocket::SetupPrimaryStreams()
 {
     NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 
     nsresult rv;
 
-    mPrimarySynStarted = mozilla::TimeStamp::Now();
     rv = SetupStreams(getter_AddRefs(mSocketTransport),
                       getter_AddRefs(mStreamIn),
                       getter_AddRefs(mStreamOut),
                       false);
     LOG(("nsHalfOpenSocket::SetupPrimaryStream [this=%p ent=%s rv=%x]",
          this, mEnt->mConnInfo->Host(), rv));
     if (NS_FAILED(rv)) {
         if (mStreamOut)
@@ -2234,17 +2005,16 @@ nsHttpConnectionMgr::nsHalfOpenSocket::S
         mSocketTransport = nsnull;
     }
     return rv;
 }
 
 nsresult
 nsHttpConnectionMgr::nsHalfOpenSocket::SetupBackupStreams()
 {
-    mBackupSynStarted = mozilla::TimeStamp::Now();
     nsresult rv = SetupStreams(getter_AddRefs(mBackupTransport),
                                getter_AddRefs(mBackupStreamIn),
                                getter_AddRefs(mBackupStreamOut),
                                true);
     LOG(("nsHalfOpenSocket::SetupBackupStream [this=%p ent=%s rv=%x]",
          this, mEnt->mConnInfo->Host(), rv));
     if (NS_FAILED(rv)) {
         if (mBackupStreamOut)
@@ -2356,38 +2126,31 @@ nsHalfOpenSocket::OnOutputStreamReady(ns
     LOG(("nsHalfOpenSocket::OnOutputStreamReady "
          "Created new nshttpconnection %p\n", conn.get()));
 
     nsCOMPtr<nsIInterfaceRequestor> callbacks;
     nsCOMPtr<nsIEventTarget>        callbackTarget;
     mTransaction->GetSecurityCallbacks(getter_AddRefs(callbacks),
                                        getter_AddRefs(callbackTarget));
     if (out == mStreamOut) {
-        mozilla::TimeDuration rtt = 
-            mozilla::TimeStamp::Now() - mPrimarySynStarted;
         rv = conn->Init(mEnt->mConnInfo,
                         gHttpHandler->ConnMgr()->mMaxRequestDelay,
                         mSocketTransport, mStreamIn, mStreamOut,
-                        callbacks, callbackTarget,
-                        PR_MillisecondsToInterval(rtt.ToMilliseconds()));
+                        callbacks, callbackTarget);
 
         // The nsHttpConnection object now owns these streams and sockets
         mStreamOut = nsnull;
         mStreamIn = nsnull;
         mSocketTransport = nsnull;
     }
     else {
-        mozilla::TimeDuration rtt = 
-            mozilla::TimeStamp::Now() - mBackupSynStarted;
-        
         rv = conn->Init(mEnt->mConnInfo,
                         gHttpHandler->ConnMgr()->mMaxRequestDelay,
                         mBackupTransport, mBackupStreamIn, mBackupStreamOut,
-                        callbacks, callbackTarget,
-                        PR_MillisecondsToInterval(rtt.ToMilliseconds()));
+                        callbacks, callbackTarget);
 
         // The nsHttpConnection object now owns these streams and sockets
         mBackupStreamOut = nsnull;
         mBackupStreamIn = nsnull;
         mBackupTransport = nsnull;
     }
 
     if (NS_FAILED(rv)) {
@@ -2399,16 +2162,17 @@ nsHalfOpenSocket::OnOutputStreamReady(ns
     // if this is still in the pending list, remove it and dispatch it
     index = mEnt->mPendingQ.IndexOf(mTransaction);
     if (index != -1) {
         mEnt->mPendingQ.RemoveElementAt(index);
         nsHttpTransaction *temp = mTransaction;
         NS_RELEASE(temp);
         gHttpHandler->ConnMgr()->AddActiveConn(conn, mEnt);
         rv = gHttpHandler->ConnMgr()->DispatchTransaction(mEnt, mTransaction,
+                                                          mTransaction->Caps(),
                                                           conn);
     }
     else {
         // this transaction was dispatched off the pending q before all the
         // sockets established themselves.
 
         // We need to establish a small non-zero idle timeout so the connection
         // mgr perceives this socket as suitable for persistent connection reuse
@@ -2529,301 +2293,16 @@ nsHttpConnectionMgr::nsConnectionHandle:
 
     NS_ASSERTION(mConn, "no connection");
     nsHttpConnection *conn = mConn;
     mConn = nsnull;
     return conn;
 }
 
 bool
-nsHttpConnectionMgr::nsConnectionHandle::IsProxyConnectInProgress()
-{
-    return mConn->IsProxyConnectInProgress();
-}
-
-PRUint32
-nsHttpConnectionMgr::nsConnectionHandle::CancelPipeline(nsresult reason)
-{
-    // no pipeline to cancel
-    return 0;
-}
-
-nsAHttpTransaction::Classifier
-nsHttpConnectionMgr::nsConnectionHandle::Classification()
-{
-    if (mConn)
-        return mConn->Classification();
-
-    LOG(("nsConnectionHandle::Classification this=%p "
-         "has null mConn using CLASS_SOLO default", this));
-    return nsAHttpTransaction::CLASS_SOLO;
-}
-
-void
-nsHttpConnectionMgr::
-nsConnectionHandle::Classify(nsAHttpTransaction::Classifier newclass)
-{
-    if (mConn)
-        mConn->Classify(newclass);
-}
-
-// nsConnectionEntry
-
-nsHttpConnectionMgr::
-nsConnectionEntry::nsConnectionEntry(nsHttpConnectionInfo *ci)
-    : mConnInfo(ci)
-    , mPipelineState(PS_YELLOW)
-    , mYellowGoodEvents(0)
-    , mYellowBadEvents(0)
-    , mYellowConnection(nsnull)
-    , mGreenDepth(kPipelineOpen)
-    , mPipeliningPenalty(0)
-    , mUsingSpdy(false)
-    , mTestedSpdy(false)
-    , mSpdyPreferred(false)
-{
-    NS_ADDREF(mConnInfo);
-    if (gHttpHandler->GetPipelineAggressive()) {
-        mGreenDepth = kPipelineUnlimited;
-        mPipelineState = PS_GREEN;
-    }
-    mInitialGreenDepth = mGreenDepth;
-    memset(mPipeliningClassPenalty, 0, sizeof(PRInt16) * nsAHttpTransaction::CLASS_MAX);
-}
-
-bool
-nsHttpConnectionMgr::nsConnectionEntry::SupportsPipelining()
-{
-    return mPipelineState != nsHttpConnectionMgr::PS_RED;
-}
-
-nsHttpConnectionMgr::PipeliningState
-nsHttpConnectionMgr::nsConnectionEntry::PipelineState()
-{
-    return mPipelineState;
-}
-    
-void
-nsHttpConnectionMgr::
-nsConnectionEntry::OnPipelineFeedbackInfo(
-    nsHttpConnectionMgr::PipelineFeedbackInfoType info,
-    nsHttpConnection *conn,
-    PRUint32 data)
-{
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
-    
-    if (mPipelineState == PS_YELLOW) {
-        if (info & kPipelineInfoTypeBad)
-            mYellowBadEvents++;
-        else if (info & (kPipelineInfoTypeNeutral | kPipelineInfoTypeGood))
-            mYellowGoodEvents++;
-    }
-    
-    if (mPipelineState == PS_GREEN && info == GoodCompletedOK) {
-        PRInt32 depth = data;
-        LOG(("Transaction completed at pipeline depty of %d. Host = %s\n",
-             depth, mConnInfo->Host()));
-
-        if (depth >= 3)
-            mGreenDepth = kPipelineUnlimited;
-    }
-
-    nsAHttpTransaction::Classifier classification;
-    if (conn)
-        classification = conn->Classification();
-    else if (info == BadInsufficientFraming ||
-             info == BadUnexpectedLarge)
-        classification = (nsAHttpTransaction::Classifier) data;
-    else
-        classification = nsAHttpTransaction::CLASS_SOLO;
-
-    if (gHttpHandler->GetPipelineAggressive() &&
-        info & kPipelineInfoTypeBad &&
-        info != BadExplicitClose &&
-        info != RedVersionTooLow &&
-        info != RedBannedServer &&
-        info != RedCorruptedContent &&
-        info != BadInsufficientFraming) {
-        LOG(("minor negative feedback ignored "
-             "because of pipeline aggressive mode"));
-    }
-    else if (info & kPipelineInfoTypeBad) {
-        if ((info & kPipelineInfoTypeRed) && (mPipelineState != PS_RED)) {
-            LOG(("transition to red from %d. Host = %s.\n",
-                 mPipelineState, mConnInfo->Host()));
-            mPipelineState = PS_RED;
-            mPipeliningPenalty = 0;
-        }
-
-        if (mLastCreditTime.IsNull())
-            mLastCreditTime = mozilla::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:
-            NS_ABORT_IF_FALSE(0, "Unknown Bad/Red Pipeline Feedback Event");
-        }
-        
-        mPipeliningPenalty = PR_MIN(mPipeliningPenalty, 25000);
-        mPipeliningClassPenalty[classification] = PR_MIN(mPipeliningClassPenalty[classification], 25000);
-            
-        LOG(("Assessing red penalty to %s class %d for event %d. "
-             "Penalty now %d, throttle[%d] = %d\n", mConnInfo->Host(),
-             classification, info, mPipeliningPenalty, classification,
-             mPipeliningClassPenalty[classification]));
-    }
-    else {
-        // hand out credits for neutral and good events such as
-        // "headers look ok" events
-
-        mPipeliningPenalty = PR_MAX(mPipeliningPenalty - 1, 0);
-        mPipeliningClassPenalty[classification] = PR_MAX(mPipeliningClassPenalty[classification] - 1, 0);
-    }
-
-    if (mPipelineState == PS_RED && !mPipeliningPenalty)
-    {
-        LOG(("transition %s to yellow\n", mConnInfo->Host()));
-        mPipelineState = PS_YELLOW;
-        mYellowConnection = nsnull;
-    }
-}
-
-void
-nsHttpConnectionMgr::
-nsConnectionEntry::SetYellowConnection(nsHttpConnection *conn)
-{
-    NS_ABORT_IF_FALSE(!mYellowConnection && mPipelineState == PS_YELLOW,
-                      "yellow connection already set or state is not yellow");
-    mYellowConnection = conn;
-    mYellowGoodEvents = mYellowBadEvents = 0;
-}
-
-void
-nsHttpConnectionMgr::nsConnectionEntry::OnYellowComplete()
-{
-    if (mPipelineState == PS_YELLOW) {
-        if (mYellowGoodEvents && !mYellowBadEvents) {
-            LOG(("transition %s to green\n", mConnInfo->Host()));
-            mPipelineState = PS_GREEN;
-            mGreenDepth = mInitialGreenDepth;
-        }
-        else {
-            // The purpose of the yellow state is to witness at least
-            // one successful pipelined transaction without seeing any
-            // kind of negative feedback before opening the flood gates.
-            // If we haven't confirmed that, then transfer back to red.
-            LOG(("transition %s to red from yellow return\n",
-                 mConnInfo->Host()));
-            mPipelineState = PS_RED;
-        }
-    }
-
-    mYellowConnection = nsnull;
-}
-
-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)
-
-    mozilla::TimeStamp now = mozilla::TimeStamp::Now();
-    mozilla::TimeDuration elapsedTime = now - mLastCreditTime;
-    PRUint32 creditsEarned =
-        static_cast<PRUint32>(elapsedTime.ToSeconds()) >> 4;
-    
-    bool failed = false;
-    if (creditsEarned > 0) {
-        mPipeliningPenalty = 
-            PR_MAX(PRInt32(mPipeliningPenalty - creditsEarned), 0);
-        if (mPipeliningPenalty > 0)
-            failed = true;
-        
-        for (PRInt32 i = 0; i < nsAHttpTransaction::CLASS_MAX; ++i) {
-            mPipeliningClassPenalty[i]  =
-                PR_MAX(PRInt32(mPipeliningClassPenalty[i] - creditsEarned), 0);
-            failed = failed || (mPipeliningClassPenalty[i] > 0);
-        }
-
-        // update last credit mark to reflect elapsed time
-        mLastCreditTime +=
-            mozilla::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 = mozilla::TimeStamp();    /* reset to null timestamp */
-
-    if (mPipelineState == PS_RED && !mPipeliningPenalty)
-    {
-        LOG(("transition %s to yellow based on time credit\n",
-             mConnInfo->Host()));
-        mPipelineState = PS_YELLOW;
-        mYellowConnection = nsnull;
-    }    
-}
-
-PRUint32
-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::nsConnectionHandle::LastTransactionExpectedNoContent()
 {
     return mConn->LastTransactionExpectedNoContent();
 }
 
 void
 nsHttpConnectionMgr::
 nsConnectionHandle::SetLastTransactionExpectedNoContent(bool val)
--- a/netwerk/protocol/http/nsHttpConnectionMgr.h
+++ b/netwerk/protocol/http/nsHttpConnectionMgr.h
@@ -44,23 +44,22 @@
 #include "nsHttpTransaction.h"
 #include "nsTArray.h"
 #include "nsThreadUtils.h"
 #include "nsClassHashtable.h"
 #include "nsDataHashtable.h"
 #include "nsAutoPtr.h"
 #include "mozilla/ReentrantMonitor.h"
 #include "nsISocketTransportService.h"
-#include "mozilla/TimeStamp.h"
 
 #include "nsIObserver.h"
 #include "nsITimer.h"
 #include "nsIX509Cert3.h"
 
-#include "nsHttpPipeline.h"
+class nsHttpPipeline;
 
 //-----------------------------------------------------------------------------
 
 class nsHttpConnectionMgr : public nsIObserver
 {
 public:
     NS_DECL_ISUPPORTS
     NS_DECL_NSIOBSERVER
@@ -68,34 +67,32 @@ public:
     // parameter names
     enum nsParamName {
         MAX_CONNECTIONS,
         MAX_CONNECTIONS_PER_HOST,
         MAX_CONNECTIONS_PER_PROXY,
         MAX_PERSISTENT_CONNECTIONS_PER_HOST,
         MAX_PERSISTENT_CONNECTIONS_PER_PROXY,
         MAX_REQUEST_DELAY,
-        MAX_PIPELINED_REQUESTS,
-        MAX_OPTIMISTIC_PIPELINED_REQUESTS
+        MAX_PIPELINED_REQUESTS
     };
 
     //-------------------------------------------------------------------------
     // NOTE: functions below may only be called on the main thread.
     //-------------------------------------------------------------------------
 
     nsHttpConnectionMgr();
 
     nsresult Init(PRUint16 maxConnections,
                   PRUint16 maxConnectionsPerHost,
                   PRUint16 maxConnectionsPerProxy,
                   PRUint16 maxPersistentConnectionsPerHost,
                   PRUint16 maxPersistentConnectionsPerProxy,
                   PRUint16 maxRequestDelay,
-                  PRUint16 maxPipelinedRequests,
-                  PRUint16 maxOptimisticPipelinedRequests);
+                  PRUint16 maxPipelinedRequests);
     nsresult Shutdown();
 
     //-------------------------------------------------------------------------
     // NOTE: functions below may be called on any thread.
     //-------------------------------------------------------------------------
 
     // Schedules next pruning of dead connection to happen after
     // given time.
@@ -136,192 +133,66 @@ public:
     // been initialized.
     nsresult UpdateParam(nsParamName name, PRUint16 value);
 
     // Lookup/Cancel HTTP->SPDY redirections
     bool GetSpdyAlternateProtocol(nsACString &key);
     void ReportSpdyAlternateProtocol(nsHttpConnection *);
     void RemoveSpdyAlternateProtocol(nsACString &key);
 
-    // Pipielining Interfaces and Datatypes
-
-    const static PRUint32 kPipelineInfoTypeMask = 0xffff0000;
-    const static PRUint32 kPipelineInfoIDMask   = ~kPipelineInfoTypeMask;
-
-    const static PRUint32 kPipelineInfoTypeRed     = 0x00010000;
-    const static PRUint32 kPipelineInfoTypeBad     = 0x00020000;
-    const static PRUint32 kPipelineInfoTypeNeutral = 0x00040000;
-    const static PRUint32 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 *,
-                                  PRUint32);
-
-    void ReportFailedToProcess(nsIURI *uri);
-
     //-------------------------------------------------------------------------
     // NOTE: functions below may be called only on the socket thread.
     //-------------------------------------------------------------------------
 
+    // removes the next transaction for the specified connection from the
+    // pending transaction queue.
+    void AddTransactionToPipeline(nsHttpPipeline *);
+
     // called to force the transaction queue to be processed once more, giving
     // preference to the specified connection.
     nsresult ProcessPendingQ(nsHttpConnectionInfo *);
-    bool     ProcessPendingQForEntry(nsHttpConnectionInfo *);
 
     // This is used to force an idle connection to be closed and removed from
     // the idle connection list. It is called when the idle connection detects
     // 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 *);
-
 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;
     
-    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.
     //
-    class nsConnectionEntry
+    struct nsConnectionEntry
     {
-    public:
-        nsConnectionEntry(nsHttpConnectionInfo *ci);
+        nsConnectionEntry(nsHttpConnectionInfo *ci)
+          : mConnInfo(ci),
+            mUsingSpdy(false),
+            mTestedSpdy(false),
+            mSpdyPreferred(false)
+        {
+            NS_ADDREF(mConnInfo);
+        }
         ~nsConnectionEntry();
 
         nsHttpConnectionInfo        *mConnInfo;
         nsTArray<nsHttpTransaction*> mPendingQ;    // pending transaction queue
         nsTArray<nsHttpConnection*>  mActiveConns; // active connections
         nsTArray<nsHttpConnection*>  mIdleConns;   // idle persistent connections
         nsTArray<nsHalfOpenSocket*>  mHalfOpens;
 
-        // Pipeline depths for various states
-        const static PRUint32 kPipelineUnlimited  = 1024; // fully open - extended green
-        const static PRUint32 kPipelineOpen       = 6;    // 6 on each conn - normal green
-        const static PRUint32 kPipelineRestricted = 2;    // 2 on just 1 conn in yellow
-        
-        nsHttpConnectionMgr::PipeliningState PipelineState();
-        void OnPipelineFeedbackInfo(
-            nsHttpConnectionMgr::PipelineFeedbackInfoType info,
-            nsHttpConnection *, PRUint32);
-        bool SupportsPipelining();
-        PRUint32 MaxPipelineDepth(nsAHttpTransaction::Classifier classification);
-        void CreditPenalty();
-
-        nsHttpConnectionMgr::PipeliningState mPipelineState;
-
-        void SetYellowConnection(nsHttpConnection *);
-        void OnYellowComplete();
-        PRUint32                  mYellowGoodEvents;
-        PRUint32                  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.
-        PRUint32                  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.
-        PRUint32                  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.
-        PRInt16                   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.
-        PRInt16                   mPipeliningClassPenalty[nsAHttpTransaction::CLASS_MAX];
-
-        // for calculating penalty repair credits
-        mozilla::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.
@@ -396,19 +267,16 @@ private:
 
     private:
         nsConnectionEntry              *mEnt;
         nsRefPtr<nsHttpTransaction>    mTransaction;
         nsCOMPtr<nsISocketTransport>   mSocketTransport;
         nsCOMPtr<nsIAsyncOutputStream> mStreamOut;
         nsCOMPtr<nsIAsyncInputStream>  mStreamIn;
 
-        mozilla::TimeStamp             mPrimarySynStarted;
-        mozilla::TimeStamp             mBackupSynStarted;
-
         // for syn retry
         nsCOMPtr<nsITimer>             mSynTimer;
         nsCOMPtr<nsISocketTransport>   mBackupTransport;
         nsCOMPtr<nsIAsyncOutputStream> mBackupStreamOut;
         nsCOMPtr<nsIAsyncInputStream>  mBackupStreamIn;
     };
     friend class nsHalfOpenSocket;
 
@@ -423,57 +291,44 @@ private:
     // connection limits
     PRUint16 mMaxConns;
     PRUint16 mMaxConnsPerHost;
     PRUint16 mMaxConnsPerProxy;
     PRUint16 mMaxPersistConnsPerHost;
     PRUint16 mMaxPersistConnsPerProxy;
     PRUint16 mMaxRequestDelay; // in seconds
     PRUint16 mMaxPipelinedRequests;
-    PRUint16 mMaxOptimisticPipelinedRequests;
+
     bool mIsShuttingDown;
 
     //-------------------------------------------------------------------------
     // NOTE: these members are only accessed on the socket transport thread
     //-------------------------------------------------------------------------
 
     static PLDHashOperator ProcessOneTransactionCB(const nsACString &, nsAutoPtr<nsConnectionEntry> &, void *);
 
     static PLDHashOperator PruneDeadConnectionsCB(const nsACString &, nsAutoPtr<nsConnectionEntry> &, void *);
     static PLDHashOperator ShutdownPassCB(const nsACString &, nsAutoPtr<nsConnectionEntry> &, void *);
     static PLDHashOperator PurgeExcessIdleConnectionsCB(const nsACString &, nsAutoPtr<nsConnectionEntry> &, void *);
     static PLDHashOperator ClosePersistentConnectionsCB(const nsACString &, nsAutoPtr<nsConnectionEntry> &, void *);
     bool     ProcessPendingQForEntry(nsConnectionEntry *);
-    bool     IsUnderPressure(nsConnectionEntry *ent,
-                             nsHttpTransaction::Classifier classification);
     bool     AtActiveConnectionLimit(nsConnectionEntry *, PRUint8 caps);
-    nsresult TryDispatchTransaction(nsConnectionEntry *ent,
-                                    bool onlyReusedConnection,
-                                    nsHttpTransaction *trans);
-    nsresult DispatchTransaction(nsConnectionEntry *,
-                                 nsHttpTransaction *,
-                                 nsHttpConnection *);
-    nsresult BuildPipeline(nsConnectionEntry *,
-                           nsAHttpTransaction *,
-                           nsHttpPipeline **);
+    void     GetConnection(nsConnectionEntry *, nsHttpTransaction *,
+                           bool, nsHttpConnection **);
+    nsresult DispatchTransaction(nsConnectionEntry *, nsHttpTransaction *,
+                                 PRUint8 caps, nsHttpConnection *);
+    bool     BuildPipeline(nsConnectionEntry *, nsAHttpTransaction *, nsHttpPipeline **);
     nsresult ProcessNewTransaction(nsHttpTransaction *);
     nsresult EnsureSocketThreadTargetIfOnline();
     void     ClosePersistentConnections(nsConnectionEntry *ent);
     nsresult CreateTransport(nsConnectionEntry *, nsHttpTransaction *);
     void     AddActiveConn(nsHttpConnection *, nsConnectionEntry *);
     void     StartedConnect();
     void     RecvdConnect();
 
-    bool     MakeNewConnection(nsConnectionEntry *ent,
-                               nsHttpTransaction *trans);
-    bool     AddToShortestPipeline(nsConnectionEntry *ent,
-                                   nsHttpTransaction *trans,
-                                   nsHttpTransaction::Classifier classification,
-                                   PRUint16 depthLimit);
-
     // Manage the preferred spdy connection entry for this address
     nsConnectionEntry *GetSpdyPreferredEnt(nsConnectionEntry *aOriginalEntry);
     void               RemoveSpdyPreferredEnt(nsACString &aDottedDecimal);
     nsHttpConnection  *GetSpdyPreferredConn(nsConnectionEntry *ent);
     nsDataHashtable<nsCStringHashKey, nsConnectionEntry *>   mSpdyPreferredHash;
     nsConnectionEntry *LookupConnectionEntry(nsHttpConnectionInfo *ci,
                                              nsHttpConnection *conn,
                                              nsHttpTransaction *trans);
@@ -536,17 +391,16 @@ private:
     void OnMsgNewTransaction       (PRInt32, void *);
     void OnMsgReschedTransaction   (PRInt32, void *);
     void OnMsgCancelTransaction    (PRInt32, void *);
     void OnMsgProcessPendingQ      (PRInt32, void *);
     void OnMsgPruneDeadConnections (PRInt32, void *);
     void OnMsgReclaimConnection    (PRInt32, void *);
     void OnMsgUpdateParam          (PRInt32, void *);
     void OnMsgClosePersistentConnections (PRInt32, void *);
-    void OnMsgProcessFeedback      (PRInt32, void *);
 
     // Total number of active connections in all of the ConnectionEntry objects
     // that are accessed from mCT connection table.
     PRUint16 mNumActiveConns;
     // Total number of idle connections in all of the ConnectionEntry objects
     // that are accessed from mCT connection table.
     PRUint16 mNumIdleConns;
 
--- a/netwerk/protocol/http/nsHttpHandler.cpp
+++ b/netwerk/protocol/http/nsHttpHandler.cpp
@@ -180,26 +180,21 @@ nsHttpHandler::nsHttpHandler()
     , mSpdyTimeout(PR_SecondsToInterval(180))
     , mMaxRequestAttempts(10)
     , mMaxRequestDelay(10)
     , mIdleSynTimeout(250)
     , mMaxConnections(24)
     , mMaxConnectionsPerServer(8)
     , mMaxPersistentConnectionsPerServer(2)
     , mMaxPersistentConnectionsPerProxy(4)
-    , mMaxPipelinedRequests(32)
-    , mMaxOptimisticPipelinedRequests(4)
-    , mPipelineAggressive(false)
-    , mMaxPipelineObjectSize(300000)
-    , mPipelineReadTimeout(PR_MillisecondsToInterval(10000))
+    , mMaxPipelinedRequests(2)
     , mRedirectionLimit(10)
     , mPhishyUserPassLength(1)
     , mQoSBits(0x00)
     , mPipeliningOverSSL(false)
-    , mEnforceAssocReq(false)
     , mInPrivateBrowsingMode(PRIVATE_BROWSING_UNKNOWN)
     , mLastUniqueID(NowInSeconds())
     , mSessionStartTime(0)
     , mLegacyAppName("Mozilla")
     , mLegacyAppVersion("5.0")
     , mProduct("Gecko")
     , mUserAgentIsDirty(true)
     , mUseCache(true)
@@ -338,17 +333,16 @@ nsHttpHandler::Init()
     mObserverService = mozilla::services::GetObserverService();
     if (mObserverService) {
         mObserverService->AddObserver(this, "profile-change-net-teardown", true);
         mObserverService->AddObserver(this, "profile-change-net-restore", true);
         mObserverService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);
         mObserverService->AddObserver(this, "net:clear-active-logins", true);
         mObserverService->AddObserver(this, NS_PRIVATE_BROWSING_SWITCH_TOPIC, true);
         mObserverService->AddObserver(this, "net:prune-dead-connections", true);
-        mObserverService->AddObserver(this, "net:failed-to-process-uri", true);
     }
  
     return NS_OK;
 }
 
 nsresult
 nsHttpHandler::InitConnectionMgr()
 {
@@ -364,18 +358,17 @@ nsHttpHandler::InitConnectionMgr()
     }
 
     rv = mConnMgr->Init(mMaxConnections,
                         mMaxConnectionsPerServer,
                         mMaxConnectionsPerServer,
                         mMaxPersistentConnectionsPerServer,
                         mMaxPersistentConnectionsPerProxy,
                         mMaxRequestDelay,
-                        mMaxPipelinedRequests,
-                        mMaxOptimisticPipelinedRequests);
+                        mMaxPipelinedRequests);
     return rv;
 }
 
 nsresult
 nsHttpHandler::AddStandardRequestHeaders(nsHttpHeaderArray *request,
                                          PRUint8 caps,
                                          bool useProxy)
 {
@@ -1017,57 +1010,23 @@ nsHttpHandler::PrefsChanged(nsIPrefBranc
             else
                 mCapabilities &= ~NS_HTTP_ALLOW_PIPELINING;
         }
     }
 
     if (PREF_CHANGED(HTTP_PREF("pipelining.maxrequests"))) {
         rv = prefs->GetIntPref(HTTP_PREF("pipelining.maxrequests"), &val);
         if (NS_SUCCEEDED(rv)) {
-            mMaxPipelinedRequests = clamped(val, 1, 0xffff);
+            mMaxPipelinedRequests = clamped(val, 1, NS_HTTP_MAX_PIPELINED_REQUESTS);
             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<PRInt64>(clamped(val, 1000, 100000000));
-        }
-    }
-
-    if (PREF_CHANGED(HTTP_PREF("pipelining.read-timeout"))) {
-        rv = prefs->GetIntPref(HTTP_PREF("pipelining.read-timeout"), &val);
-        if (NS_SUCCEEDED(rv)) {
-            mPipelineReadTimeout =
-                PR_MillisecondsToInterval(clamped(val, 500, 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);
@@ -1139,23 +1098,16 @@ nsHttpHandler::PrefsChanged(nsIPrefBranc
 
     if (PREF_CHANGED(HTTP_PREF("prompt-temp-redirect"))) {
         rv = prefs->GetBoolPref(HTTP_PREF("prompt-temp-redirect"), &cVar);
         if (NS_SUCCEEDED(rv)) {
             mPromptTempRedirect = cVar;
         }
     }
 
-    if (PREF_CHANGED(HTTP_PREF("assoc-req.enforce"))) {
-        cVar = false;
-        rv = prefs->GetBoolPref(HTTP_PREF("assoc-req.enforce"), &cVar);
-        if (NS_SUCCEEDED(rv))
-            mEnforceAssocReq = cVar;
-    }
-
     // enable Persistent caching for HTTPS - bug#205921    
     if (PREF_CHANGED(BROWSER_PREF("disk_cache_ssl"))) {
         cVar = false;
         rv = prefs->GetBoolPref(BROWSER_PREF("disk_cache_ssl"), &cVar);
         if (NS_SUCCEEDED(rv))
             mEnablePersistentHttpsCaching = cVar;
     }
 
@@ -1630,21 +1582,16 @@ nsHttpHandler::Observe(nsISupports *subj
         if (mConnMgr)
             mConnMgr->ClosePersistentConnections();
     }
     else if (strcmp(topic, "net:prune-dead-connections") == 0) {
         if (mConnMgr) {
             mConnMgr->PruneDeadConnections();
         }
     }
-    else if (strcmp(topic, "net:failed-to-process-uri") == 0) {
-        nsCOMPtr<nsIURI> uri = do_QueryInterface(subject);
-        if (uri && mConnMgr)
-            mConnMgr->ReportFailedToProcess(uri);
-    }
   
     return NS_OK;
 }
 
 //-----------------------------------------------------------------------------
 // nsHttpsHandler implementation
 //-----------------------------------------------------------------------------
 
--- a/netwerk/protocol/http/nsHttpHandler.h
+++ b/netwerk/protocol/http/nsHttpHandler.h
@@ -105,17 +105,16 @@ public:
     PRUint16       MaxRequestAttempts()      { return mMaxRequestAttempts; }
     const char    *DefaultSocketType()       { return mDefaultSocketType.get(); /* ok to return null */ }
     nsIIDNService *IDNConverter()            { return mIDNConverter; }
     PRUint32       PhishyUserPassLength()    { return mPhishyUserPassLength; }
     PRUint8        GetQoSBits()              { return mQoSBits; }
     PRUint16       GetIdleSynTimeout()       { return mIdleSynTimeout; }
     bool           FastFallbackToIPv4()      { return mFastFallbackToIPv4; }
     PRUint32       MaxSocketCount();
-    bool           EnforceAssocReq()         { return mEnforceAssocReq; }
 
     bool           IsPersistentHttpsCachingEnabled() { return mEnablePersistentHttpsCaching; }
     bool           IsTelemetryEnabled() { return mTelemetryEnabled; }
     bool           AllowExperiments() { return mTelemetryEnabled && mAllowExperiments; }
 
     bool           IsSpdyEnabled() { return mEnableSpdy; }
     bool           CoalesceSpdy() { return mCoalesceSpdy; }
     bool           UseAlternateProtocol() { return mUseAlternateProtocol; }
@@ -227,23 +226,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, PRInt32 port,
                                      nsCString& hostLine);
 
-    bool GetPipelineAggressive()     { return mPipelineAggressive; }
-    void GetMaxPipelineObjectSize(PRInt64 &outVal)
-    {
-        outVal = mMaxPipelineObjectSize;
-    }
-    PRIntervalTime GetPipelineTimeout()   { return mPipelineReadTimeout; }
-
 private:
 
     //
     // Useragent/prefs helper methods
     //
     void     BuildUserAgent();
     void     InitUserAgentComponents();
     void     PrefsChanged(nsIPrefBranch *prefs, const char *pref);
@@ -290,35 +282,29 @@ private:
     PRUint16 mMaxRequestAttempts;
     PRUint16 mMaxRequestDelay;
     PRUint16 mIdleSynTimeout;
 
     PRUint16 mMaxConnections;
     PRUint8  mMaxConnectionsPerServer;
     PRUint8  mMaxPersistentConnectionsPerServer;
     PRUint8  mMaxPersistentConnectionsPerProxy;
-    PRUint16 mMaxPipelinedRequests;
-    PRUint16 mMaxOptimisticPipelinedRequests;
-    bool     mPipelineAggressive;
-    PRInt64  mMaxPipelineObjectSize;
-
-    PRIntervalTime mPipelineReadTimeout;
+    PRUint8  mMaxPipelinedRequests;
 
     PRUint8  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.
     PRUint8  mPhishyUserPassLength;
 
     PRUint8  mQoSBits;
 
     bool mPipeliningOverSSL;
-    bool mEnforceAssocReq;
 
     // cached value of whether or not the browser is in private browsing mode.
     enum {
         PRIVATE_BROWSING_OFF = false,
         PRIVATE_BROWSING_ON = true,
         PRIVATE_BROWSING_UNKNOWN = 2
     } mInPrivateBrowsingMode;
 
--- a/netwerk/protocol/http/nsHttpPipeline.cpp
+++ b/netwerk/protocol/http/nsHttpPipeline.cpp
@@ -93,17 +93,16 @@ private:
 //-----------------------------------------------------------------------------
 
 nsHttpPipeline::nsHttpPipeline()
     : mConnection(nsnull)
     , mStatus(NS_OK)
     , mRequestIsPartial(false)
     , mResponseIsPartial(false)
     , mClosed(false)
-    , mUtilizedPipeline(false)
     , mPushBackBuf(nsnull)
     , mPushBackLen(0)
     , mPushBackMax(0)
     , mHttp1xTransactionCount(0)
     , mReceivingFromProgress(0)
     , mSendingToProgress(0)
     , mSuppressSendEvents(true)
 {
@@ -120,72 +119,29 @@ nsHttpPipeline::~nsHttpPipeline()
         free(mPushBackBuf);
 }
 
 nsresult
 nsHttpPipeline::AddTransaction(nsAHttpTransaction *trans)
 {
     LOG(("nsHttpPipeline::AddTransaction [this=%x trans=%x]\n", this, trans));
 
-    if (mRequestQ.Length() || mResponseQ.Length())
-        mUtilizedPipeline = true;
-
     NS_ADDREF(trans);
     mRequestQ.AppendElement(trans);
-    PRUint32 qlen = PipelineDepth();
-    
-    if (qlen != 1) {
-        trans->SetPipelinePosition(qlen);
+
+    if (mConnection && !mClosed) {
+        trans->SetConnection(this);
+
+        if (mRequestQ.Length() == 1)
+            mConnection->ResumeSend();
     }
-    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;
 }
 
-PRUint32
-nsHttpPipeline::PipelineDepth()
-{
-    return mRequestQ.Length() + mResponseQ.Length();
-}
-
-nsresult
-nsHttpPipeline::SetPipelinePosition(PRInt32 position)
-{
-    nsAHttpTransaction *trans = Response(0);
-    if (trans)
-        return trans->SetPipelinePosition(position);
-    return NS_OK;
-}
-
-PRInt32
-nsHttpPipeline::PipelinePosition()
-{
-    nsAHttpTransaction *trans = Response(0);
-    if (trans)
-        return trans->PipelinePosition();
-    return 2;
-}
-
-nsHttpPipeline *
-nsHttpPipeline::QueryPipeline()
-{
-    return this;
-}
-
 //-----------------------------------------------------------------------------
 // nsHttpPipeline::nsISupports
 //-----------------------------------------------------------------------------
 
 NS_IMPL_THREADSAFE_ADDREF(nsHttpPipeline)
 NS_IMPL_THREADSAFE_RELEASE(nsHttpPipeline)
 
 // multiple inheritance fun :-)
@@ -203,36 +159,19 @@ nsHttpPipeline::OnHeadersAvailable(nsAHt
                                    nsHttpRequestHead *requestHead,
                                    nsHttpResponseHead *responseHead,
                                    bool *reset)
 {
     LOG(("nsHttpPipeline::OnHeadersAvailable [this=%x]\n", this));
 
     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
     NS_ASSERTION(mConnection, "no connection");
-    
-    nsRefPtr<nsHttpConnectionInfo> ci;
-    GetConnectionInfo(getter_AddRefs(ci));
 
-    NS_ABORT_IF_FALSE(ci, "no connection info");
-    
-    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;
+    return mConnection->OnHeadersAvailable(trans, requestHead, responseHead, reset);
 }
 
 nsresult
 nsHttpPipeline::ResumeSend()
 {
     if (mConnection)
         return mConnection->ResumeSend();
     return NS_ERROR_UNEXPECTED;
@@ -247,17 +186,17 @@ nsHttpPipeline::ResumeRecv()
 }
 
 void
 nsHttpPipeline::CloseTransaction(nsAHttpTransaction *trans, nsresult reason)
 {
     LOG(("nsHttpPipeline::CloseTransaction [this=%x trans=%x reason=%x]\n",
         this, trans, reason));
 
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
+    NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
     NS_ASSERTION(NS_FAILED(reason), "expecting failure code");
 
     // the specified transaction is to be closed with the given "reason"
     
     PRInt32 index;
     bool killPipeline = false;
 
     index = mRequestQ.IndexOf(trans);
@@ -275,37 +214,31 @@ nsHttpPipeline::CloseTransaction(nsAHttp
             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. Don't tear it down yet
-    // as that would prevent Response(0) from being processed.
-    DontReuse();
-
     trans->Close(reason);
     NS_RELEASE(trans);
 
-    if (killPipeline)
-        // reschedule anything from this pipeline onto a different connection
-        CancelPipeline(reason);
+    if (killPipeline) {
+        if (mConnection)
+            mConnection->CloseTransaction(this, reason);
+        else
+            Close(reason);
+    }
 }
 
 void
 nsHttpPipeline::GetConnectionInfo(nsHttpConnectionInfo **result)
 {
-    if (!mConnection) {
-        *result = nsnull;
-        return;
-    }
-
+    NS_ASSERTION(mConnection, "no connection");
     mConnection->GetConnectionInfo(result);
 }
 
 nsresult
 nsHttpPipeline::TakeTransport(nsISocketTransport  **aTransport,
                               nsIAsyncInputStream **aInputStream,
                               nsIAsyncOutputStream **aOutputStream)
 {
@@ -323,34 +256,25 @@ 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();
+    return true; // pipelining requires this
 }
 
 nsresult
 nsHttpPipeline::PushBack(const char *data, PRUint32 length)
 {
     LOG(("nsHttpPipeline::PushBack [this=%x len=%u]\n", this, length));
     
-    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
+    NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
     NS_ASSERTION(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
@@ -381,23 +305,16 @@ nsHttpPipeline::PushBack(const char *dat
  
     memcpy(mPushBackBuf, data, length);
     mPushBackLen = length;
 
     return NS_OK;
 }
 
 bool
-nsHttpPipeline::IsProxyConnectInProgress()
-{
-    NS_ABORT_IF_FALSE(mConnection, "no connection");
-    return mConnection->IsProxyConnectInProgress();
-}
-
-bool
 nsHttpPipeline::LastTransactionExpectedNoContent()
 {
     NS_ABORT_IF_FALSE(mConnection, "no connection");
     return mConnection->LastTransactionExpectedNoContent();
 }
 
 void
 nsHttpPipeline::SetLastTransactionExpectedNoContent(bool val)
@@ -417,34 +334,16 @@ nsHttpPipeline::TakeHttpConnection()
 nsISocketTransport *
 nsHttpPipeline::Transport()
 {
     if (!mConnection)
         return nsnull;
     return mConnection->Transport();
 }
 
-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::Classify(nsAHttpTransaction::Classifier newclass)
-{
-    if (mConnection)
-        mConnection->Classify(newclass);
-}
-
 void
 nsHttpPipeline::SetSSLConnectFailed()
 {
     nsAHttpTransaction *trans = Request(0);
 
     if (trans)
         trans->SetSSLConnectFailed();
 }
@@ -488,28 +387,32 @@ nsHttpPipeline::TakeSubTransactions(
     }
     mRequestQ.Clear();
 
     LOG(("   took %d\n", count));
     return NS_OK;
 }
 
 //-----------------------------------------------------------------------------
-// nsHttpPipeline::nsAHttpTransaction
+// nsHttpPipeline::nsAHttpConnection
 //-----------------------------------------------------------------------------
 
 void
 nsHttpPipeline::SetConnection(nsAHttpConnection *conn)
 {
     LOG(("nsHttpPipeline::SetConnection [this=%x conn=%x]\n", this, conn));
 
     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
     NS_ASSERTION(!mConnection, "already have a connection");
 
     NS_IF_ADDREF(mConnection = conn);
+
+    PRInt32 i, count = mRequestQ.Length();
+    for (i=0; i<count; ++i)
+        Request(i)->SetConnection(this);
 }
 
 nsAHttpConnection *
 nsHttpPipeline::Connection()
 {
     LOG(("nsHttpPipeline::Connection [this=%x conn=%x]\n", this, mConnection));
 
     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
@@ -517,23 +420,18 @@ nsHttpPipeline::Connection()
 }
 
 void
 nsHttpPipeline::GetSecurityCallbacks(nsIInterfaceRequestor **result,
                                      nsIEventTarget        **target)
 {
     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 
-    // 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.
+    // return security callbacks from first request
     nsAHttpTransaction *trans = Request(0);
-    if (!trans)
-        trans = Response(0);
     if (trans)
         trans->GetSecurityCallbacks(result, target);
     else {
         *result = nsnull;
         if (target)
             *target = nsnull;
     }
 }
@@ -643,26 +541,16 @@ nsHttpPipeline::IsDone()
 }
 
 nsresult
 nsHttpPipeline::Status()
 {
     return mStatus;
 }
 
-PRUint8
-nsHttpPipeline::Caps()
-{
-    nsAHttpTransaction *trans = Request(0);
-    if (!trans)
-        trans = Response(0);
-
-    return trans ? trans->Caps() : 0;
-}
-
 PRUint32
 nsHttpPipeline::Available()
 {
     PRUint32 result = 0;
 
     PRInt32 i, count = mRequestQ.Length();
     for (i=0; i<count; ++i)
         result += Request(i)->Available();
@@ -739,27 +627,16 @@ nsHttpPipeline::WriteSegments(nsAHttpSeg
 
     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 an SSL 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 {
         // 
@@ -772,20 +649,17 @@ nsHttpPipeline::WriteSegments(nsAHttpSeg
             trans->Close(NS_OK);
             NS_RELEASE(trans);
             mResponseQ.RemoveElementAt(0);
             mResponseIsPartial = false;
             ++mHttp1xTransactionCount;
 
             // ask the connection manager to add additional transactions
             // to our pipeline.
-            nsRefPtr<nsHttpConnectionInfo> ci;
-            GetConnectionInfo(getter_AddRefs(ci));
-            if (ci)
-                gHttpHandler->ConnMgr()->ProcessPendingQForEntry(ci);
+            gHttpHandler->ConnMgr()->AddTransactionToPipeline(this);
         }
         else
             mResponseIsPartial = true;
     }
 
     if (mPushBackLen) {
         nsHttpPushBackWriter writer(mPushBackBuf, mPushBackLen);
         PRUint32 len = mPushBackLen, n;
@@ -804,107 +678,62 @@ nsHttpPipeline::WriteSegments(nsAHttpSeg
         // so we are guaranteed that the next response will eat the entire
         // push back buffer (even though it might again call PushBack).
         rv = WriteSegments(&writer, len, &n);
     }
 
     return rv;
 }
 
-PRUint32
-nsHttpPipeline::CancelPipeline(nsresult originalReason)
-{
-    PRUint32 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);
-        NS_RELEASE(trans);
-    }
-    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
-    for (i = 1; i < respLen; ++i) {
-        trans = Response(i);
-        trans->Close(NS_ERROR_NET_RESET);
-        NS_RELEASE(trans);
-    }
-
-    if (respLen > 1)
-        mResponseQ.TruncateLength(1);
-
-    DontReuse();
-    Classify(nsAHttpTransaction::CLASS_SOLO);
-
-    return total;
-}
-
 void
 nsHttpPipeline::Close(nsresult reason)
 {
     LOG(("nsHttpPipeline::Close [this=%x reason=%x]\n", this, reason));
 
     if (mClosed) {
         LOG(("  already closed\n"));
         return;
     }
 
     // the connection is going away!
     mStatus = reason;
     mClosed = true;
 
-    nsRefPtr<nsHttpConnectionInfo> ci;
-    GetConnectionInfo(getter_AddRefs(ci));
-    PRUint32 numRescheduled = CancelPipeline(reason);
+    PRUint32 i, count;
+    nsAHttpTransaction *trans;
 
-    // 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, nsnull, 0);
+    // any pending requests can ignore this error and be restarted
+    count = mRequestQ.Length();
+    for (i=0; i<count; ++i) {
+        trans = Request(i);
+        trans->Close(NS_ERROR_NET_RESET);
+        NS_RELEASE(trans);
+    }
+    mRequestQ.Clear();
 
-    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_BASE_STREAM_CLOSED)) {
-        trans->Close(NS_ERROR_NET_RESET);
-    }
-    else {
-        trans->Close(reason);
+    trans = Response(0);
+    if (trans) {
+        // if the current response is partially complete, then it cannot be
+        // restarted and will have to fail with the status of the connection.
+        if (mResponseIsPartial)
+            trans->Close(reason);
+        else
+            trans->Close(NS_ERROR_NET_RESET);
+        NS_RELEASE(trans);
+        
+        // any remaining pending responses can be restarted
+        count = mResponseQ.Length();
+        for (i=1; i<count; ++i) {
+            trans = Response(i);
+            trans->Close(NS_ERROR_NET_RESET);
+            NS_RELEASE(trans);
+        }
+        mResponseQ.Clear();
     }
 
-    NS_RELEASE(trans);
-    mResponseQ.Clear();
 }
 
 nsresult
 nsHttpPipeline::OnReadSegment(const char *segment,
                               PRUint32 count,
                               PRUint32 *countRead)
 {
     return mSendBufOut->Write(segment, count, countRead);
@@ -930,23 +759,16 @@ nsHttpPipeline::FillSendBuf()
 
     PRUint32 n, avail;
     nsAHttpTransaction *trans;
     nsITransport *transport = Transport();
 
     while ((trans = Request(0)) != nsnull) {
         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, avail, &n);
             if (NS_FAILED(rv)) return rv;
             
             if (n == 0) {
                 LOG(("send pipe is full"));
                 break;
             }
 
@@ -967,18 +789,14 @@ nsHttpPipeline::FillSendBuf()
             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;
 }
--- a/netwerk/protocol/http/nsHttpPipeline.h
+++ b/netwerk/protocol/http/nsHttpPipeline.h
@@ -55,16 +55,18 @@ public:
     NS_DECL_ISUPPORTS
     NS_DECL_NSAHTTPCONNECTION
     NS_DECL_NSAHTTPTRANSACTION
     NS_DECL_NSAHTTPSEGMENTREADER
 
     nsHttpPipeline();
     virtual ~nsHttpPipeline();
 
+    nsresult AddTransaction(nsAHttpTransaction *);
+
 private:
     nsresult FillSendBuf();
     
     static NS_METHOD ReadFromPipe(nsIInputStream *, void *, const char *,
                                   PRUint32, PRUint32, PRUint32 *);
 
     // convenience functions
     nsAHttpTransaction *Request(PRInt32 i)
@@ -77,38 +79,31 @@ private:
     nsAHttpTransaction *Response(PRInt32 i)
     {
         if (mResponseQ.Length() == 0)
             return nsnull;
 
         return mResponseQ[i];
     }
 
-    // overload of nsAHttpTransaction::QueryPipeline()
-    nsHttpPipeline *QueryPipeline();
-
     nsAHttpConnection            *mConnection;
     nsTArray<nsAHttpTransaction*> mRequestQ;  // array of transactions
     nsTArray<nsAHttpTransaction*> mResponseQ; // array of transactions
     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;
     nsAHttpSegmentWriter *mWriter;
 
     // send buffer
     nsCOMPtr<nsIInputStream>  mSendBufIn;
     nsCOMPtr<nsIOutputStream> mSendBufOut;
 
--- a/netwerk/protocol/http/nsHttpTransaction.cpp
+++ b/netwerk/protocol/http/nsHttpTransaction.cpp
@@ -59,18 +59,16 @@
 #include "nsStringStream.h"
 
 #include "nsComponentManagerUtils.h" // do_CreateInstance
 #include "nsServiceManagerUtils.h"   // do_GetService
 #include "nsIHttpActivityObserver.h"
 
 #include "mozilla/FunctionTimer.h"
 
-using namespace mozilla;
-
 //-----------------------------------------------------------------------------
 
 #ifdef DEBUG
 // defined by the socket transport service while active
 extern PRThread *gSocketThread;
 #endif
 
 //-----------------------------------------------------------------------------
@@ -116,89 +114,46 @@ nsHttpTransaction::nsHttpTransaction()
     , mContentLength(-1)
     , mContentRead(0)
     , mInvalidResponseBytesRead(0)
     , mChunkedDecoder(nsnull)
     , mStatus(NS_OK)
     , mPriority(0)
     , mRestartCount(0)
     , mCaps(0)
-    , mClassification(CLASS_GENERAL)
-    , mPipelinePosition(0)
     , mClosed(false)
     , mConnected(false)
     , mHaveStatusLine(false)
     , mHaveAllHeaders(false)
     , mTransactionDone(false)
     , mResponseIsComplete(false)
     , mDidContentStart(false)
     , mNoContent(false)
     , mSentData(false)
     , mReceivedData(false)
     , mStatusEventPending(false)
     , mHasRequestBody(false)
     , mSSLConnectFailed(false)
     , mHttpResponseMatched(false)
     , mPreserveStream(false)
-    , mToReadBeforeRestart(0)
-    , mReportedStart(false)
-    , mReportedResponseHeader(false)
-    , mForTakeResponseHead(nsnull)
-    , mTakenResponseHeader(false)
 {
     LOG(("Creating nsHttpTransaction @%x\n", this));
-    gHttpHandler->GetMaxPipelineObjectSize(mMaxPipelineObjectSize);
 }
 
 nsHttpTransaction::~nsHttpTransaction()
 {
     LOG(("Destroying nsHttpTransaction @%x\n", this));
 
     NS_IF_RELEASE(mConnection);
     NS_IF_RELEASE(mConnInfo);
 
     delete mResponseHead;
-    delete mForTakeResponseHead;
     delete mChunkedDecoder;
 }
 
-nsHttpTransaction::Classifier
-nsHttpTransaction::Classify()
-{
-    if (!(mCaps & NS_HTTP_ALLOW_PIPELINING))
-        return (mClassification = CLASS_SOLO);
-
-    if (mRequestHead->PeekHeader(nsHttp::If_Modified_Since) ||
-        mRequestHead->PeekHeader(nsHttp::If_None_Match))
-        return (mClassification = CLASS_REVALIDATION);
-
-    const char *accept = mRequestHead->PeekHeader(nsHttp::Accept);
-    if (accept && !PL_strncmp(accept, "image/", 6))
-        return (mClassification = CLASS_IMAGE);
-
-    if (accept && !PL_strncmp(accept, "text/css", 8))
-        return (mClassification = CLASS_SCRIPT);
-
-    mClassification = CLASS_GENERAL;
-
-    PRInt32 queryPos = mRequestHead->RequestURI().FindChar('?');
-    if (queryPos == kNotFound) {
-        if (StringEndsWith(mRequestHead->RequestURI(),
-                           NS_LITERAL_CSTRING(".js")))
-            mClassification = CLASS_SCRIPT;
-    }
-    else if (queryPos >= 3 &&
-             Substring(mRequestHead->RequestURI(), queryPos - 3, 3).
-             EqualsLiteral(".js")) {
-        mClassification = CLASS_SCRIPT;
-    }
-
-    return mClassification;
-}
-
 nsresult
 nsHttpTransaction::Init(PRUint8 caps,
                         nsHttpConnectionInfo *cinfo,
                         nsHttpRequestHead *requestHead,
                         nsIInputStream *requestBody,
                         bool requestBodyHasHeaders,
                         nsIEventTarget *target,
                         nsIInterfaceRequestor *callbacks,
@@ -340,55 +295,36 @@ nsHttpTransaction::Init(PRUint8 caps,
     // create pipe for response stream
     rv = NS_NewPipe2(getter_AddRefs(mPipeIn),
                      getter_AddRefs(mPipeOut),
                      true, true,
                      nsIOService::gDefaultSegmentSize,
                      nsIOService::gDefaultSegmentCount);
     if (NS_FAILED(rv)) return rv;
 
-    Classify();
-
     NS_ADDREF(*responseBody = mPipeIn);
     return NS_OK;
 }
 
 nsAHttpConnection *
 nsHttpTransaction::Connection()
 {
     return mConnection;
 }
 
 nsHttpResponseHead *
 nsHttpTransaction::TakeResponseHead()
 {
-    NS_ABORT_IF_FALSE(!mTakenResponseHeader, "TakeResponseHead called 2x");
-
-    // Lock RestartInProgress() and TakeResponseHead() against main thread
-    MutexAutoLock lock(*nsHttp::GetLock());
-
-    mTakenResponseHeader = true;
-
-    // Even in OnStartRequest() the headers won't be available if we were
-    // canceled
     if (!mHaveAllHeaders) {
         NS_WARNING("response headers not available or incomplete");
         return nsnull;
     }
 
-    // Prefer mForTakeResponseHead over mResponseHead
-    nsHttpResponseHead *head;
-    if (mForTakeResponseHead) {
-        head = mForTakeResponseHead;
-        mForTakeResponseHead = nsnull;
-    }
-    else {
-        head = mResponseHead;
-        mResponseHead = nsnull;
-    }
+    nsHttpResponseHead *head = mResponseHead;
+    mResponseHead = nsnull;
     return head;
 }
 
 void
 nsHttpTransaction::SetSSLConnectFailed()
 {
     mSSLConnectFailed = true;
 }
@@ -464,24 +400,23 @@ nsHttpTransaction::OnTransportStatus(nsI
             (status == nsISocketTransport::STATUS_WAITING_FOR))
             mActivityDistributor->ObserveActivity(
                 mChannel,
                 NS_HTTP_ACTIVITY_TYPE_HTTP_TRANSACTION,
                 NS_HTTP_ACTIVITY_SUBTYPE_REQUEST_BODY_SENT,
                 PR_Now(), LL_ZERO, EmptyCString());
 
         // report the status and progress
-        if (!mRestartInProgressVerifier.Active())
-            mActivityDistributor->ObserveActivity(
-                mChannel,
-                NS_HTTP_ACTIVITY_TYPE_SOCKET_TRANSPORT,
-                static_cast<PRUint32>(status),
-                PR_Now(),
-                progress,
-                EmptyCString());
+        mActivityDistributor->ObserveActivity(
+            mChannel,
+            NS_HTTP_ACTIVITY_TYPE_SOCKET_TRANSPORT,
+            static_cast<PRUint32>(status),
+            PR_Now(),
+            progress,
+            EmptyCString());
     }
 
     // nsHttpChannel synthesizes progress events in OnDataAvailable
     if (status == nsISocketTransport::STATUS_RECEIVING_FROM)
         return;
 
     PRUint64 progressMax;
 
@@ -516,22 +451,16 @@ nsHttpTransaction::IsDone()
 }
 
 nsresult
 nsHttpTransaction::Status()
 {
     return mStatus;
 }
 
-PRUint8
-nsHttpTransaction::Caps()
-{ 
-    return mCaps;
-}
-
 PRUint32
 nsHttpTransaction::Available()
 {
     PRUint32 size;
     if (NS_FAILED(mRequestStream->Available(&size)))
         size = 0;
     return size;
 }
@@ -720,57 +649,26 @@ nsHttpTransaction::Close(nsresult reason
     // have dire consequences including repeated purchases, etc.
     //
     // NOTE: because of the way SSL proxy CONNECT is implemented, it is
     // possible that the transaction may have received data without having
     // sent any data.  for this reason, mSendData == FALSE does not imply
     // mReceivedData == FALSE.  (see bug 203057 for more info.)
     //
     if (reason == NS_ERROR_NET_RESET || reason == NS_OK) {
-        if (!mReceivedData && (!mSentData || connReused || mPipelinePosition)) {
+        if (!mReceivedData && (!mSentData || 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,
-                    nsnull, 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, nsnull, 0);
-            if (NS_SUCCEEDED(RestartInProgress()))
-                return;
-        }
     }
 
     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,
-                nsnull, mClassification);
-        }
-        else if (mPipelinePosition) {
-            // report this success as feedback
-            gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-                mConnInfo, nsHttpConnectionMgr::GoodCompletedOK,
-                nsnull, 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';
             PRUint32 unused;
             ParseHead(&data, 1, &unused);
@@ -801,97 +699,21 @@ nsHttpTransaction::Close(nsresult reason
         delete mChunkedDecoder;
         mChunkedDecoder = nsnull;
     }
 
     // closing this pipe triggers the channel's OnStopRequest method.
     mPipeOut->CloseWithStatus(reason);
 }
 
-nsresult
-nsHttpTransaction::AddTransaction(nsAHttpTransaction *trans)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-PRUint32
-nsHttpTransaction::PipelineDepth()
-{
-    return IsDone() ? 0 : 1;
-}
-
-nsresult
-nsHttpTransaction::SetPipelinePosition(PRInt32 position)
-{
-    mPipelinePosition = position;
-    return NS_OK;
-}
- 
-PRInt32
-nsHttpTransaction::PipelinePosition()
-{
-    return mPipelinePosition;
-}
-
 //-----------------------------------------------------------------------------
 // nsHttpTransaction <private>
 //-----------------------------------------------------------------------------
 
 nsresult
-nsHttpTransaction::RestartInProgress()
-{
-    NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
-    
-    // Lock RestartInProgress() and TakeResponseHead() against main thread
-    MutexAutoLock lock(*nsHttp::GetLock());
-
-    // don't try and restart 0.9
-    if (mHaveAllHeaders && !mRestartInProgressVerifier.IsSetup())
-        return NS_ERROR_NET_RESET;
-
-    LOG(("Will restart transaction %p and skip first %lld bytes, "
-         "old Content-Length %lld",
-         this, mContentRead, mContentLength));
-
-    if (mHaveAllHeaders) {
-        mRestartInProgressVerifier.SetAlreadyProcessed(
-            PR_MAX(mRestartInProgressVerifier.AlreadyProcessed(), mContentRead));
-        mToReadBeforeRestart = mRestartInProgressVerifier.AlreadyProcessed();
-        mRestartInProgressVerifier.SetActive(true);
-
-        if (!mTakenResponseHeader && !mForTakeResponseHead) {
-            // TakeResponseHeader() has not been called yet and this
-            // is the first restart. Store the resp headers exclusively
-            // for TakeResponseHeader()
-            mForTakeResponseHead = mResponseHead;
-            mResponseHead = nsnull;
-        }
-    }
-
-    if (mResponseHead) {
-        mResponseHead->Reset();
-    }
-
-    mContentRead = 0;
-    mContentLength = -1;
-    delete mChunkedDecoder;
-    mChunkedDecoder = nsnull;
-    mHaveStatusLine = false;
-    mHaveAllHeaders = false;
-    mHttpResponseMatched = false;
-    mResponseIsComplete = false;
-    mDidContentStart = false;
-    mNoContent = false;
-    mSentData = false;
-    mReceivedData = false;
-
-    return Restart();
-}
-
-nsresult
 nsHttpTransaction::Restart()
 {
     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 
     // limit the number of restart attempts - bug 92224
     if (++mRestartCount >= gHttpHandler->MaxRequestAttempts()) {
         LOG(("reached max request attempts, failing transaction @%x\n", this));
         return NS_ERROR_NET_RESET;
@@ -1012,19 +834,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.BeginWriting());
             mLineBuf.Truncate();
             if (NS_FAILED(rv)) {
-                gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-                    mConnInfo, nsHttpConnectionMgr::RedCorruptedContent,
-                    nsnull, 0);
                 return rv;
             }
         }
     }
 
     // append segment to mLineBuf...
     mLineBuf.Append(segment, len);
     
@@ -1063,24 +882,22 @@ nsHttpTransaction::ParseHead(char *buf,
         
     // allocate the response head object if necessary
     if (!mResponseHead) {
         mResponseHead = new nsHttpResponseHead();
         if (!mResponseHead)
             return NS_ERROR_OUT_OF_MEMORY;
 
         // report that we have a least some of the response
-        if (mActivityDistributor && !mReportedStart) {
-            mReportedStart = true;
+        if (mActivityDistributor)
             mActivityDistributor->ObserveActivity(
                 mChannel,
                 NS_HTTP_ACTIVITY_TYPE_HTTP_TRANSACTION,
                 NS_HTTP_ACTIVITY_SUBTYPE_RESPONSE_START,
                 PR_Now(), LL_ZERO, EmptyCString());
-        }
     }
 
     if (!mHttpResponseMatched) {
         // Normally we insist on seeing HTTP/1.x in the first few bytes,
         // but if we are on a persistent connection and the previous transaction
         // was not supposed to have any content then we need to be prepared
         // to skip over a response body that the server may have sent even
         // though it wasn't allowed.
@@ -1184,18 +1001,17 @@ nsHttpTransaction::HandleContentStart()
             nsCAutoString headers;
             mResponseHead->Flatten(headers, false);
             LogHeaders(headers.get());
             LOG3(("]\n"));
         }
 #endif
         // 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;
@@ -1212,31 +1028,23 @@ nsHttpTransaction::HandleContentStart()
         case 204:
         case 205:
         case 304:
             mNoContent = true;
             LOG(("this response should not contain a body.\n"));
             break;
         }
         mConnection->SetLastTransactionExpectedNoContent(mNoContent);
-        if (mInvalidResponseBytesRead)
-            gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-                mConnInfo, nsHttpConnectionMgr::BadInsufficientFraming,
-                nsnull, mClassification);
 
         if (mNoContent)
             mContentLength = 0;
         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.
             // ignore chunked responses from HTTP/1.0 servers and proxies.
             if (mResponseHead->Version() >= NS_HTTP_VERSION_1_1 &&
                 mResponseHead->HasHeaderValue(nsHttp::Transfer_Encoding, "chunked")) {
                 // we only support the "chunked" transfer encoding right now.
@@ -1247,25 +1055,19 @@ nsHttpTransaction::HandleContentStart()
                 // Ignore server specified Content-Length.
                 mContentLength = -1;
             }
 #if defined(PR_LOGGING)
             else if (mContentLength == PRInt64(-1))
                 LOG(("waiting for the server to close the connection.\n"));
 #endif
         }
-        if (mRestartInProgressVerifier.Active() &&
-            !mRestartInProgressVerifier.Verify(mContentLength, mResponseHead)) {
-            LOG(("Restart in progress subsequent transaction failed to match"));
-            return NS_ERROR_ABORT;
-        }
     }
 
     mDidContentStart = true;
-    mRestartInProgressVerifier.Set(mContentLength, mResponseHead);
     return NS_OK;
 }
 
 // called on the socket thread
 nsresult
 nsHttpTransaction::HandleContent(char *buf,
                                  PRUint32 count,
                                  PRUint32 *contentRead,
@@ -1314,49 +1116,29 @@ nsHttpTransaction::HandleContent(char *b
             }
         }
     }
     else {
         // when we are just waiting for the server to close the connection...
         // (no explicit content-length given)
         *contentRead = count;
     }
-    
-    if (mRestartInProgressVerifier.Active() &&
-        mToReadBeforeRestart && *contentRead) {
-        PRUint32 ignore = PR_MIN(*contentRead, PRUint32(mToReadBeforeRestart));
-        LOG(("Due To Restart ignoring %d of remaining %ld",
-             ignore, mToReadBeforeRestart));
-        *contentRead -= ignore;
-        mContentRead += ignore;
-        mToReadBeforeRestart -= ignore;
-        memmove(buf, buf + ignore, *contentRead + *contentRemaining);
-        if (!mToReadBeforeRestart)
-            mRestartInProgressVerifier.SetActive(false);
-    }
 
     if (*contentRead) {
         // update count of content bytes read and report progress...
         mContentRead += *contentRead;
         /* when uncommenting, take care of 64-bit integers w/ NS_MAX...
         if (mProgressSink)
             mProgressSink->OnProgress(nsnull, nsnull, mContentRead, NS_MAX(0, mContentLength));
         */
     }
 
     LOG(("nsHttpTransaction::HandleContent [this=%x count=%u read=%u mContentRead=%lld mContentLength=%lld]\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 > 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;
 
         if (TimingEnabled())
@@ -1402,19 +1184,17 @@ nsHttpTransaction::ProcessData(char *buf
         
         count -= bytesConsumed;
 
         // if buf has some content in it, shift bytes to top of buf.
         if (count && bytesConsumed)
             memmove(buf, buf + bytesConsumed, count);
 
         // report the completed response header
-        if (mActivityDistributor && mResponseHead && mHaveAllHeaders &&
-            !mReportedResponseHeader) {
-            mReportedResponseHeader = true;
+        if (mActivityDistributor && mResponseHead && mHaveAllHeaders) {
             nsCAutoString completeResponseHeaders;
             mResponseHead->Flatten(completeResponseHeaders, false);
             completeResponseHeaders.AppendLiteral("\r\n");
             mActivityDistributor->ObserveActivity(
                 mChannel,
                 NS_HTTP_ACTIVITY_TYPE_HTTP_TRANSACTION,
                 NS_HTTP_ACTIVITY_SUBTYPE_RESPONSE_HEADER,
                 PR_Now(), LL_ZERO,
@@ -1448,33 +1228,16 @@ nsHttpTransaction::ProcessData(char *buf
             NS_ASSERTION(mConnection, "no connection");
             mConnection->PushBack(buf + *countRead, countRemaining);
         }
     }
 
     return NS_OK;
 }
 
-void
-nsHttpTransaction::CancelPipeline(PRUint32 reason)
-{
-    // reason is casted through a uint to avoid compiler header deps
-    gHttpHandler->ConnMgr()->PipelineFeedbackInfo(
-        mConnInfo,
-        static_cast<nsHttpConnectionMgr::PipelineFeedbackInfoType>(reason),
-        nsnull, mClassification);
-
-    mConnection->CancelPipeline(NS_ERROR_CORRUPTED_CONTENT);
-
-    // 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;
-}
-
 //-----------------------------------------------------------------------------
 // nsHttpTransaction deletion event
 //-----------------------------------------------------------------------------
 
 class nsDeleteHttpTransaction : public nsRunnable {
 public:
     nsDeleteHttpTransaction(nsHttpTransaction *trans)
         : mTrans(trans)
@@ -1560,81 +1323,8 @@ nsHttpTransaction::OnOutputStreamReady(n
 {
     if (mConnection) {
         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)
-{
-    const char *val;
-    
-    val = newHead->PeekHeader(headerAtom);
-    if (val && old.IsEmpty())
-        return false;
-    if (!val && !old.IsEmpty())
-        return false;
-    if (val && !old.Equals(val))
-        return false;
-    return true;
-}
-
-bool
-nsHttpTransaction::RestartVerifier::Verify(PRInt64 contentLength,
-                                           nsHttpResponseHead *newHead)
-{
-    if (mContentLength != contentLength)
-        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(PRInt64 contentLength,
-                                        nsHttpResponseHead *head)
-{
-    if (mSetup)
-        return;
-
-    mContentLength = contentLength;
-    
-    if (head) {
-        const char *val;
-        val = head->PeekHeader(nsHttp::ETag);
-        if (val)
-            mETag.Assign(val);
-        val = head->PeekHeader(nsHttp::Last_Modified);
-        if (val)
-            mLastModified.Assign(val);
-        val = head->PeekHeader(nsHttp::Content_Range);
-        if (val)
-            mContentRange.Assign(val);
-        val = head->PeekHeader(nsHttp::Content_Encoding);
-        if (val)
-            mContentEncoding.Assign(val);
-        val = head->PeekHeader(nsHttp::Transfer_Encoding);
-        if (val)
-            mTransferEncoding.Assign(val);
-        mSetup = true;
-    }
-}
--- a/netwerk/protocol/http/nsHttpTransaction.h
+++ b/netwerk/protocol/http/nsHttpTransaction.h
@@ -108,16 +108,17 @@ public:
                   nsIInputStream        *reqBody,
                   bool                   reqBodyIncludesHeaders,
                   nsIEventTarget        *consumerTarget,
                   nsIInterfaceRequestor *callbacks,
                   nsITransportEventSink *eventsink,
                   nsIAsyncInputStream  **responseBody);
 
     // attributes
+    PRUint8                Caps()           { return mCaps; }
     nsHttpConnectionInfo  *ConnectionInfo() { return mConnInfo; }
     nsHttpResponseHead    *ResponseHead()   { return mHaveAllHeaders ? mResponseHead : nsnull; }
     nsISupports           *SecurityInfo()   { return mSecurityInfo; }
 
     nsIInterfaceRequestor *Callbacks()      { return mCallbacks; } 
     nsIEventTarget        *ConsumerTarget() { return mConsumerTarget; }
 
     // Called to take ownership of the response headers; the transaction
@@ -129,34 +130,29 @@ public:
 
     bool      SSLConnectFailed() { return mSSLConnectFailed; }
 
     // SetPriority() may only be used by the connection manager.
     void    SetPriority(PRInt32 priority) { mPriority = priority; }
     PRInt32    Priority()                 { return mPriority; }
 
     const TimingStruct& Timings() const { return mTimings; }
-    enum Classifier Classification() { return mClassification; }
 
 private:
     nsresult Restart();
-    nsresult RestartInProgress();
     char    *LocateHttpStart(char *buf, PRUint32 len,
                              bool aAllowPartialMatch);
     nsresult ParseLine(char *line);
     nsresult ParseLineSegment(char *seg, PRUint32 len);
     nsresult ParseHead(char *, PRUint32 count, PRUint32 *countRead);
     nsresult HandleContentStart();
     nsresult HandleContent(char *, PRUint32 count, PRUint32 *contentRead, PRUint32 *contentRemaining);
     nsresult ProcessData(char *, PRUint32, PRUint32 *);
     void     DeleteSelfOnConsumerThread();
 
-    Classifier Classify();
-    void       CancelPipeline(PRUint32 reason);
-
     static NS_METHOD ReadRequestSegment(nsIInputStream *, void *, const char *,
                                         PRUint32, PRUint32, PRUint32 *);
     static NS_METHOD WritePipeSegment(nsIOutputStream *, void *, char *,
                                       PRUint32, PRUint32, PRUint32 *);
 
     bool TimingEnabled() const { return mCaps & NS_HTTP_TIMING_ENABLED; }
 
 private:
@@ -199,19 +195,16 @@ private:
     TimingStruct                    mTimings;
 
     nsresult                        mStatus;
 
     PRInt16                         mPriority;
 
     PRUint16                        mRestartCount;        // the number of times this transaction has been restarted
     PRUint8                         mCaps;
-    enum Classifier                 mClassification;
-    PRInt32                         mPipelinePosition;
-    PRInt64                         mMaxPipelineObjectSize;
 
     // state flags, all logically boolean, but not packed together into a
     // bitfield so as to avoid bitfield-induced races.  See bug 560579.
     bool                            mClosed;
     bool                            mConnected;
     bool                            mHaveStatusLine;
     bool                            mHaveAllHeaders;
     bool                            mTransactionDone;
@@ -224,71 +217,11 @@ private:
     bool                            mHasRequestBody;
     bool                            mSSLConnectFailed;
     bool                            mHttpResponseMatched;
     bool                            mPreserveStream;
 
     // mClosed           := transaction has been explicitly closed
     // mTransactionDone  := transaction ran to completion or was interrupted
     // mResponseComplete := transaction ran to completion
-
-    // For Restart-In-Progress Functionality
-    PRInt64                         mToReadBeforeRestart;
-    bool                            mReportedStart;
-    bool                            mReportedResponseHeader;
-
-    // protected by nsHttp::GetLock()
-    nsHttpResponseHead             *mForTakeResponseHead;
-    bool                            mTakenResponseHeader;
-
-    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)
-            , mActive(false)
-            , mSetup(false)
-        {}
-        ~RestartVerifier() {}
-        
-        void Set(PRInt64 contentLength, nsHttpResponseHead *head);
-        bool Verify(PRInt64 contentLength, nsHttpResponseHead *head);
-        bool Active() { return mActive; }
-        void SetActive(bool val) { mActive = val; }
-        bool IsSetup() { return mSetup; }
-        PRInt64 AlreadyProcessed() { return mAlreadyProcessed; }
-        void SetAlreadyProcessed(PRInt64 val) { mAlreadyProcessed = val; }
-
-    private:
-        // This is the data from the first complete response header
-        // used to make sure that all subsequent response headers match
-
-        PRInt64                         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.
-        PRInt64                         mAlreadyProcessed;
-
-        // true when iteration > 0 has started
-        bool                            mActive;
-
-        // true when ::Set has been called with a response header
-        bool                            mSetup;
-    } mRestartInProgressVerifier;
 };
 
 #endif // nsHttpTransaction_h__
--- a/netwerk/test/unit/head_channels.js
+++ b/netwerk/test/unit/head_channels.js
@@ -21,31 +21,29 @@ function read_stream(stream, count) {
   return data.join('');
 }
 
 const CL_EXPECT_FAILURE = 0x1;
 const CL_EXPECT_GZIP = 0x2;
 const CL_EXPECT_3S_DELAY = 0x4;
 const CL_SUSPEND = 0x8;
 const CL_ALLOW_UNKNOWN_CL = 0x10;
-const CL_EXPECT_LATE_FAILURE = 0x20;
 
 const SUSPEND_DELAY = 3000;
 
 /**
  * A stream listener that calls a callback function with a specified
  * context and the received data when the channel is loaded.
  *
  * Signature of the closure:
  *   void closure(in nsIRequest request, in ACString data, in JSObject context);
  *
  * This listener makes sure that various parts of the channel API are
  * implemented correctly and that the channel's status is a success code
- * (you can pass CL_EXPECT_FAILURE or CL_EXPECT_LATE_FAILURE as flags
- * to allow a failure code)
+ * (you can pass CL_EXPECT_FAILURE as flags to allow a failure code)
  *
  * Note that it also requires a valid content length on the channel and
  * is thus not fully generic.
  */
 function ChannelListener(closure, ctx, flags) {
   this._closure = closure;
   this._closurectx = ctx;
   this._flags = flags;
@@ -128,25 +126,25 @@ ChannelListener.prototype = {
   onStopRequest: function(request, context, status) {
     try {
       var success = Components.isSuccessCode(status);
       if (!this._got_onstartrequest && success)
         do_throw("onStopRequest without onStartRequest event!");
       if (this._got_onstoprequest)
         do_throw("Got second onStopRequest event!");
       this._got_onstoprequest = true;
-      if ((this._flags & (CL_EXPECT_FAILURE | CL_EXPECT_LATE_FAILURE)) && success)
+      if ((this._flags & CL_EXPECT_FAILURE) && success)
         do_throw("Should have failed to load URL (status is " + status.toString(16) + ")");
-      else if (!(this._flags & (CL_EXPECT_FAILURE | CL_EXPECT_LATE_FAILURE)) && !success)
+      else if (!(this._flags & CL_EXPECT_FAILURE) && !success)
         do_throw("Failed to load URL: " + status.toString(16));
       if (status != request.status)
         do_throw("request.status does not match status arg to onStopRequest!");
       if (request.isPending())
         do_throw("request reports itself as pending from onStopRequest!");
-      if (!(this._flags & (CL_EXPECT_FAILURE | CL_EXPECT_LATE_FAILURE)) &&
+      if (!(this._flags & CL_EXPECT_FAILURE) &&
           !(this._flags & CL_EXPECT_GZIP) &&
           this._contentLen != -1)
           do_check_eq(this._buffer.length, this._contentLen)
     } catch (ex) {
       do_throw("Error in onStopRequest: " + ex);
     }
     try {
       this._closure(request, this._buffer, this._closurectx);
deleted file mode 100644
--- a/netwerk/test/unit/test_assoc.js
+++ /dev/null
@@ -1,90 +0,0 @@
-do_load_httpd_js();
-
-var httpserver = new nsHttpServer();
-var currentTestIndex = 0;
-var tests = [
-             // this is valid
-             {url: "/assoc/assoctest?valid",
-              responseheader: [ "Assoc-Req: GET http://localhost:4444/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:4444/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:4444/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:4444/assoc/assoctest?invalid2",
-                                "Pragma: X-Verify-Assoc-Req" ],
-              flags : CL_EXPECT_LATE_FAILURE},
-];
-
-var oldPrefVal;
-var domBranch;
-
-function setupChannel(url)
-{
-    var ios = Components.classes["@mozilla.org/network/io-service;1"].
-                         getService(Ci.nsIIOService);
-    var chan = ios.newChannel("http://localhost:4444" + url, "", null);
-    return chan;
-}
-
-function startIter()
-{
-    var channel = setupChannel(tests[currentTestIndex].url);
-    channel.asyncOpen(new ChannelListener(completeIter,
-                                          channel, tests[currentTestIndex].flags), null);
-}
-
-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(4444);
-
-    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);
-}
deleted file mode 100644
--- a/netwerk/test/unit/test_mismatch_lm.js
+++ /dev/null
@@ -1,126 +0,0 @@
-do_load_httpd_js();
-var httpserver = new nsHttpServer();
-var cacheService;
-var ios;
-
-// Test the handling of a cache revalidation with mismatching last-modified
-// headers. If we get such a revalidation the cache entry should be purged.
-// see bug 717350
-
-// In this test the wrong data is from 11-16-1994 with a value of 'A',
-// and the right data is from 11-15-1994 with a value of 'B'.
-
-// the same URL is requested 3 times. the first time the wrong data comes
-// back, the second time that wrong data is revalidated with a 304 but
-// a L-M header of the right data (this triggers a cache purge), and
-// the third time the right data is returned.
-
-var listener_3 = {
-    // this listener is used to process the the request made after
-    // the cache invalidation. it expects to see the 'right data'
-
-    onStartRequest: function test_onStartR(request, ctx) {},
-    
-    onDataAvailable: function test_ODA(request, cx, inputStream,
-                                       offset, count) {
-	var data = new BinaryInputStream(inputStream).readByteArray(count);
-      
-	// This is 'B'
-	do_check_eq(data, 66);
-    },
-
-    onStopRequest: function test_onStopR(request, ctx, status) {
-	httpserver.stop(do_test_finished);
-    }
-};
-
-var listener_2 = {
-    // this listener is used to process the revalidation of the
-    // corrupted cache entry. its revalidation prompts it to be cleaned
-
-    onStartRequest: function test_onStartR(request, ctx) {},
-    
-    onDataAvailable: function test_ODA(request, cx, inputStream,
-                                       offset, count) {
-	var data = new BinaryInputStream(inputStream).readByteArray(count);
-      
-	// This is 'A' from a cache revalidation, but that reval will clean the cache
-	// because of mismatched last-modified response headers
-	
-	do_check_eq(data, 65);
-    },
-
-    onStopRequest: function test_onStopR(request, ctx, status) {
-	var channel = request.QueryInterface(Ci.nsIHttpChannel);
-
-	var chan = ios.newChannel("http://localhost:4444/test1", "", null);
-	var httpChan = chan.QueryInterface(Ci.nsIHttpChannel);
-	httpChan.requestMethod = "GET";
-	httpChan.asyncOpen(listener_3, null);
-    }
-};
-
-var listener_1 = {
-    // this listener processes the initial request from a empty cache.
-    // the server responds with the wrong data ('A')
-
-    onStartRequest: function test_onStartR(request, ctx) {},
-    
-    onDataAvailable: function test_ODA(request, cx, inputStream,
-                                       offset, count) {
-	var data = new BinaryInputStream(inputStream).readByteArray(count);
-	do_check_eq(data, 65);
-    },
-
-    onStopRequest: function test_onStopR(request, ctx, status) {
-	var channel = request.QueryInterface(Ci.nsIHttpChannel);
-
-	var chan = ios.newChannel("http://localhost:4444/test1", "", null);
-	var httpChan = chan.QueryInterface(Ci.nsIHttpChannel);
-	httpChan.requestMethod = "GET";
-	httpChan.asyncOpen(listener_2, null);
-    }
-};
-
-function run_test() {
-    do_get_profile();
-    cacheService = Cc["@mozilla.org/network/cache-service;1"].
-        getService(Ci.nsICacheService);
-    ios = Cc["@mozilla.org/network/io-service;1"]
-            .getService(Ci.nsIIOService);
-
-    cacheService.evictEntries(Ci.nsICache.STORE_ANYWHERE);
-
-    httpserver.registerPathHandler("/test1", handler);
-    httpserver.start(4444);
-
-    var chan = ios.newChannel("http://localhost:4444/test1", "", null);
-    var httpChan = chan.QueryInterface(Ci.nsIHttpChannel);
-    httpChan.requestMethod = "GET";
-    httpChan.asyncOpen(listener_1, null);
-
-    do_test_pending();
-}
-
-var iter=0;
-function handler(metadata, response) {
-    iter++;
-    if (metadata.hasHeader("If-Modified-Since")) {
-	response.setStatusLine(metadata.httpVersion, 304, "Not Modified");
-	response.setHeader("Last-Modified", "Tue, 15 Nov 1994 12:45:26 GMT", false);
-    }    
-    else {
-	response.setStatusLine(metadata.httpVersion, 200, "OK");
-	response.setHeader("Cache-Control", "max-age=0", false)
-	if (iter == 1) {
-	    // simulated wrong response
-	    response.setHeader("Last-Modified", "Wed, 16 Nov 1994 00:00:00 GMT", false);
-	    response.bodyOutputStream.write("A", 1);
-	}
-	if (iter == 3) {
-	    // 'correct' response
-	    response.setHeader("Last-Modified", "Tue, 15 Nov 1994 12:45:26 GMT", false);
-	    response.bodyOutputStream.write("B", 1);
-	}
-    }
-}
--- a/netwerk/test/unit/xpcshell.ini
+++ b/netwerk/test/unit/xpcshell.ini
@@ -1,17 +1,16 @@
 [DEFAULT]
 head = head_channels.js
 tail = 
 
 [test_307_redirect.js]
 [test_NetUtil.js]
 [test_URIs.js]
 [test_aboutblank.js]
-[test_assoc.js]
 [test_auth_proxy.js]
 [test_authentication.js]
 # Bug 675039: test hangs consistently on Android
 skip-if = os == "android"
 [test_authpromptwrapper.js]
 [test_bug203271.js]
 [test_bug248970_cache.js]
 [test_bug248970_cookie.js]
@@ -127,17 +126,16 @@ skip-if = os == "android"
 [test_gzipped_206.js]
 [test_head.js]
 [test_headers.js]
 [test_http_headers.js]
 [test_httpcancel.js]
 [test_httpsuspend.js]
 [test_idnservice.js]
 [test_localstreams.js]
-[test_mismatch_lm.js]
 [test_MIME_params.js]
 [test_multipart_streamconv.js]
 [test_multipart_streamconv_missing_lead_boundary.js]
 [test_nestedabout_serialize.js]
 [test_net_addr.js]
 # Bug 732363: test fails on windows for unknown reasons.
 skip-if = os == "win"
 [test_nojsredir.js]