Bug 558490: Infrastructure needed to support SetPriority in HttpChannelChild. a=jduell, r=dwitte
authorJason Duell <jduell.mcbugs@gmail.com>
Sat, 10 Apr 2010 21:53:35 -0700
changeset 46793 3caeea7ad0919eb8bce979332d98a399a7192ce5
parent 46792 0d23294d60560425da7523c964fc82123dece70e
child 46794 4778ffddaf845d738d8e1bd8bdad439544d102c8
push idunknown
push userunknown
push dateunknown
reviewersjduell, dwitte
bugs558490
milestone1.9.3a4pre
Bug 558490: Infrastructure needed to support SetPriority in HttpChannelChild. a=jduell, r=dwitte
netwerk/protocol/http/src/HttpBaseChannel.cpp
netwerk/protocol/http/src/HttpBaseChannel.h
netwerk/protocol/http/src/HttpChannelChild.cpp
netwerk/protocol/http/src/HttpChannelChild.h
netwerk/protocol/http/src/HttpChannelParent.cpp
netwerk/protocol/http/src/HttpChannelParent.h
netwerk/protocol/http/src/PHttpChannel.ipdl
netwerk/protocol/http/src/nsHttpChannel.cpp
netwerk/protocol/http/src/nsHttpChannel.h
--- a/netwerk/protocol/http/src/HttpBaseChannel.cpp
+++ b/netwerk/protocol/http/src/HttpBaseChannel.cpp
@@ -45,16 +45,17 @@
 #include "nsNetUtil.h"
 
 namespace mozilla {
 namespace net {
 
 HttpBaseChannel::HttpBaseChannel()
   : mStatus(NS_OK)
   , mLoadFlags(LOAD_NORMAL)
+  , mPriority(PRIORITY_NORMAL)
   , mCaps(0)
   , mRedirectionLimit(gHttpHandler->RedirectionLimit())
   , mIsPending(PR_FALSE)
   , mWasOpened(PR_FALSE)
   , mResponseHeadersModified(PR_FALSE)
   , mAllowPipelining(PR_TRUE)
   , mForceAllowThirdPartyCookie(PR_FALSE)
 {
@@ -136,22 +137,23 @@ HttpBaseChannel::Init(nsIURI *aURI,
 
   return rv;
 }
 
 //-----------------------------------------------------------------------------
 // HttpBaseChannel::nsISupports
 //-----------------------------------------------------------------------------
 
-NS_IMPL_ISUPPORTS_INHERITED4(HttpBaseChannel,
+NS_IMPL_ISUPPORTS_INHERITED5(HttpBaseChannel,
                              nsHashPropertyBag, 
                              nsIRequest,
                              nsIChannel,
                              nsIHttpChannel,
-                             nsIHttpChannelInternal)
+                             nsIHttpChannelInternal,
+                             nsISupportsPriority);
 
 //-----------------------------------------------------------------------------
 // HttpBaseChannel::nsIRequest
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
 HttpBaseChannel::GetName(nsACString& aName)
 {
@@ -795,13 +797,30 @@ NS_IMETHODIMP
 HttpBaseChannel::SetForceAllowThirdPartyCookie(PRBool aForce)
 {
   ENSURE_CALLED_BEFORE_ASYNC_OPEN();
 
   mForceAllowThirdPartyCookie = aForce;
   return NS_OK;
 }
 
+//-----------------------------------------------------------------------------
+// HttpBaseChannel::nsISupportsPriority
+//-----------------------------------------------------------------------------
+
+NS_IMETHODIMP
+HttpBaseChannel::GetPriority(PRInt32 *value)
+{
+  *value = mPriority;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HttpBaseChannel::AdjustPriority(PRInt32 delta)
+{
+  return SetPriority(mPriority + delta);
+}
+
 //------------------------------------------------------------------------------
 
 }
 }
 
--- a/netwerk/protocol/http/src/HttpBaseChannel.h
+++ b/netwerk/protocol/http/src/HttpBaseChannel.h
@@ -47,16 +47,17 @@
 #include "nsProxyInfo.h"
 #include "nsHttpRequestHead.h"
 #include "nsHttpResponseHead.h"
 #include "nsHttpConnectionInfo.h"
 #include "nsIHttpChannel.h"
 #include "nsIHttpChannelInternal.h"
 #include "nsIProgressEventSink.h"
 #include "nsIURI.h"
+#include "nsISupportsPriority.h"
 
 #define DIE_WITH_ASYNC_OPEN_MSG()                                              \
   do {                                                                         \
     fprintf(stderr,                                                            \
             "*&*&*&*&*&*&*&**&*&&*& FATAL ERROR: '%s' "                        \
             "called after AsyncOpen: %s +%d",                                  \
             __FUNCTION__, __FILE__, __LINE__);                                 \
     NS_ABORT();                                                                \
@@ -79,16 +80,17 @@ namespace net {
  * shared by nsHttpChannel and HttpChannelChild. 
  * - Note that this class has nothing to do with nsBaseChannel, which is an
  *   earlier effort at a base class for channels that somehow never made it all
  *   the way to the HTTP channel.
  */
 class HttpBaseChannel : public nsHashPropertyBag
                       , public nsIHttpChannel
                       , public nsIHttpChannelInternal
+                      , public nsISupportsPriority
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
 
   HttpBaseChannel();
   virtual ~HttpBaseChannel();
 
   nsresult Init(nsIURI *aURI, PRUint8 aCaps, nsProxyInfo *aProxyInfo);
@@ -143,16 +145,20 @@ public:
   NS_IMETHOD GetDocumentURI(nsIURI **aDocumentURI);
   NS_IMETHOD SetDocumentURI(nsIURI *aDocumentURI);
   NS_IMETHOD GetRequestVersion(PRUint32 *major, PRUint32 *minor);
   NS_IMETHOD GetResponseVersion(PRUint32 *major, PRUint32 *minor);
   NS_IMETHOD SetCookie(const char *aCookieHeader);
   NS_IMETHOD GetForceAllowThirdPartyCookie(PRBool *aForce);
   NS_IMETHOD SetForceAllowThirdPartyCookie(PRBool aForce);
 
+  // nsISupportsPriority
+  NS_IMETHOD GetPriority(PRInt32 *value);
+  NS_IMETHOD AdjustPriority(PRInt32 delta);
+
 protected:
   nsCOMPtr<nsIURI>                  mURI;
   nsCOMPtr<nsIURI>                  mOriginalURI;
   nsCOMPtr<nsIURI>                  mDocumentURI;
   nsCOMPtr<nsIStreamListener>       mListener;
   nsCOMPtr<nsISupports>             mListenerContext;
   nsCOMPtr<nsILoadGroup>            mLoadGroup;
   nsCOMPtr<nsIInterfaceRequestor>   mCallbacks;
@@ -164,16 +170,17 @@ protected:
   nsRefPtr<nsHttpConnectionInfo>    mConnectionInfo;
 
   nsCString                         mSpec; // ASCII encoded URL spec
   nsCString                         mContentTypeHint;
   nsCString                         mContentCharsetHint;
 
   nsresult                          mStatus;
   PRUint32                          mLoadFlags;
+  PRInt16                           mPriority;
   PRUint8                           mCaps;
   PRUint8                           mRedirectionLimit;
 
   PRUint8                           mIsPending                  : 1;
   PRUint8                           mWasOpened                  : 1;
   PRUint8                           mResponseHeadersModified    : 1;
   PRUint8                           mAllowPipelining            : 1;
   PRUint8                           mForceAllowThirdPartyCookie : 1;
--- a/netwerk/protocol/http/src/HttpChannelChild.cpp
+++ b/netwerk/protocol/http/src/HttpChannelChild.cpp
@@ -232,20 +232,17 @@ HttpChannelChild::AsyncOpen(nsIStreamLis
   rv = NS_CheckPortSafety(mURI);
   if (NS_FAILED(rv))
     return rv;
 
   // This corresponds to Release() in DeallocPHttpChannel 
   this->AddRef();
 
   // TODO: Combine constructor and AsyncOpen to save one IPC msg
-  if (!gNeckoChild->SendPHttpChannelConstructor(this)) {
-    // TODO: currently means "this" has been deleted! bug 529693
-    DROP_DEAD();
-  }
+  gNeckoChild->SendPHttpChannelConstructor(this);
   mListener = listener;
   mListenerContext = aContext;
 
   // TODO: serialize mConnectionInfo across to the parent, and set it on
   // the new channel somehow?
 
   // TODO: serialize mCaps across to the parent, and set it on
   // the new channel somehow?
@@ -273,27 +270,21 @@ HttpChannelChild::AsyncOpen(nsIStreamLis
 
   nsCAutoString referrerSpec;
   nsCAutoString referrerCharset;
   if (mReferrer) {
     mReferrer->GetSpec(referrerSpec);
     mReferrer->GetOriginCharset(referrerCharset);
   }
 
-  if (!SendAsyncOpen(mSpec, charset, originalSpec, originalCharset, 
-                     docSpec, docCharset, referrerSpec, referrerCharset,
-                     mLoadFlags, mRequestHeaders, mRequestHead.Method(), 
-                     mRedirectionLimit, mAllowPipelining,
-                     mForceAllowThirdPartyCookie)) {
-    // IPDL error: our destructor will be called automatically
-    // -- TODO: verify that that's the case :)
-    mListener = 0;
-    mListenerContext = 0;
-    return NS_ERROR_FAILURE;
-  }
+  SendAsyncOpen(mSpec, charset, originalSpec, originalCharset, docSpec,
+                docCharset, referrerSpec, referrerCharset, mLoadFlags,
+                mRequestHeaders, mRequestHead.Method(), mPriority,
+                mRedirectionLimit, mAllowPipelining,
+                mForceAllowThirdPartyCookie);
 
   mIsPending = PR_TRUE;
   mWasOpened = PR_TRUE;
   mState = HCC_OPENED;
 
   return NS_OK;
 }
 
@@ -496,30 +487,25 @@ HttpChannelChild::GetEntityID(nsACString
   DROP_DEAD();
 }
 
 //-----------------------------------------------------------------------------
 // HttpChannelChild::nsISupportsPriority
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
-HttpChannelChild::GetPriority(PRInt32 *aPriority)
-{
-  DROP_DEAD();
-}
-NS_IMETHODIMP
 HttpChannelChild::SetPriority(PRInt32 aPriority)
 {
-  DROP_DEAD();
-}
-
-NS_IMETHODIMP
-HttpChannelChild::AdjustPriority(PRInt32 delta)
-{
-  DROP_DEAD();
+  PRInt16 newValue = CLAMP(aPriority, PR_INT16_MIN, PR_INT16_MAX);
+  if (mPriority == newValue)
+    return NS_OK;
+  mPriority = newValue;
+  if (mWasOpened) 
+    SendSetPriority(mPriority);
+  return NS_OK;
 }
 
 //-----------------------------------------------------------------------------
 // HttpChannelChild::nsIProxiedChannel
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
 HttpChannelChild::GetProxyInfo(nsIProxyInfo **aProxyInfo)
--- a/netwerk/protocol/http/src/HttpChannelChild.h
+++ b/netwerk/protocol/http/src/HttpChannelChild.h
@@ -52,17 +52,16 @@
 #include "nsIProgressEventSink.h"
 #include "nsICachingChannel.h"
 #include "nsIApplicationCache.h"
 #include "nsIApplicationCacheChannel.h"
 #include "nsIEncodedChannel.h"
 #include "nsIUploadChannel.h"
 #include "nsIUploadChannel2.h"
 #include "nsIResumableChannel.h"
-#include "nsISupportsPriority.h"
 #include "nsIProxiedChannel.h"
 #include "nsITraceableChannel.h"
 
 namespace mozilla {
 namespace net {
 
 // TODO: replace with IPDL states
 enum HttpChannelChildState {
@@ -76,29 +75,27 @@ enum HttpChannelChildState {
 // Header file contents
 class HttpChannelChild : public PHttpChannelChild
                        , public HttpBaseChannel
                        , public nsICachingChannel
                        , public nsIUploadChannel
                        , public nsIUploadChannel2
                        , public nsIEncodedChannel
                        , public nsIResumableChannel
-                       , public nsISupportsPriority
                        , public nsIProxiedChannel
                        , public nsITraceableChannel
                        , public nsIApplicationCacheChannel
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSICACHINGCHANNEL
   NS_DECL_NSIUPLOADCHANNEL
   NS_DECL_NSIUPLOADCHANNEL2
   NS_DECL_NSIENCODEDCHANNEL
   NS_DECL_NSIRESUMABLECHANNEL
-  NS_DECL_NSISUPPORTSPRIORITY
   NS_DECL_NSIPROXIEDCHANNEL
   NS_DECL_NSITRACEABLECHANNEL
   NS_DECL_NSIAPPLICATIONCACHECONTAINER
   NS_DECL_NSIAPPLICATIONCACHECHANNEL
 
   HttpChannelChild();
   virtual ~HttpChannelChild();
 
@@ -116,16 +113,18 @@ public:
   NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo);
   NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext);
   // HttpBaseChannel::nsIHttpChannel
   NS_IMETHOD SetRequestHeader(const nsACString& aHeader, 
                               const nsACString& aValue, 
                               PRBool aMerge);
   // nsIHttpChannelInternal
   NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey);
+  // nsISupportsPriority
+  NS_IMETHOD SetPriority(PRInt32 value);
 
 protected:
   bool RecvOnStartRequest(const nsHttpResponseHead& responseHead);
   bool RecvOnDataAvailable(const nsCString& data, 
                            const PRUint32& offset,
                            const PRUint32& count);
   bool RecvOnStopRequest(const nsresult& statusCode);
 
--- a/netwerk/protocol/http/src/HttpChannelParent.cpp
+++ b/netwerk/protocol/http/src/HttpChannelParent.cpp
@@ -37,16 +37,17 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "mozilla/net/HttpChannelParent.h"
 #include "nsHttpChannel.h"
 #include "nsHttpHandler.h"
 #include "nsNetUtil.h"
+#include "nsISupportsPriority.h"
 
 namespace mozilla {
 namespace net {
 
 // C++ file contents
 HttpChannelParent::HttpChannelParent()
 {
   // Ensure gHttpHandler is initialized: we need the atom table up and running.
@@ -80,16 +81,17 @@ HttpChannelParent::RecvAsyncOpen(const n
                                  const nsCString&           originalCharset,
                                  const nsCString&           docUriSpec, 
                                  const nsCString&           docCharset,
                                  const nsCString&           referrerSpec,
                                  const nsCString&           referrerCharset,
                                  const PRUint32&            loadFlags,
                                  const RequestHeaderTuples& requestHeaders,
                                  const nsHttpAtom&          requestMethod,
+                                 const PRUint16&            priority,
                                  const PRUint8&             redirectionLimit,
                                  const PRBool&              allowPipelining,
                                  const PRBool&              forceAllowThirdPartyCookie)
 {
   LOG(("HttpChannelParent RecvAsyncOpen [this=%x uri=%s (%s)]\n", 
        this, uriSpec.get(), charset.get()));
 
   nsresult rv;
@@ -141,27 +143,36 @@ HttpChannelParent::RecvAsyncOpen(const n
                                requestHeaders[i].mValue,
                                requestHeaders[i].mMerge);
 
   // TODO: implement needed interfaces, and either proxy calls back to child
   // process, or rig up appropriate hacks.
   //  httpChan->SetNotificationCallbacks(this);
 
   httpChan->SetRequestMethod(nsDependentCString(requestMethod.get()));
+  if (priority != nsISupportsPriority::PRIORITY_NORMAL)
+    httpChan->SetPriority(priority);
   httpChan->SetRedirectionLimit(redirectionLimit);
   httpChan->SetAllowPipelining(allowPipelining);
   httpChan->SetForceAllowThirdPartyCookie(forceAllowThirdPartyCookie);
 
   rv = httpChan->AsyncOpen(this, nsnull);
   if (NS_FAILED(rv))
     return false;       // TODO: send fail msg to child, return true
 
   return true;
 }
 
+bool 
+HttpChannelParent::RecvSetPriority(const PRUint16& priority)
+{
+  // FIXME: bug XXX: once we figure out how to keep a ref to the nsHttpChannel,
+  // call SetPriority on it here.
+  return true;
+}
 
 //-----------------------------------------------------------------------------
 // HttpChannelParent::nsIRequestObserver
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
 HttpChannelParent::OnStartRequest(nsIRequest *aRequest, nsISupports *aContext)
 {
--- a/netwerk/protocol/http/src/HttpChannelParent.h
+++ b/netwerk/protocol/http/src/HttpChannelParent.h
@@ -71,17 +71,20 @@ protected:
                              const nsCString&           originalCharset,
                              const nsCString&           docUriSpec, 
                              const nsCString&           docCharset,
                              const nsCString&           referrerSpec,
                              const nsCString&           referrerCharset,
                              const PRUint32&            loadFlags,
                              const RequestHeaderTuples& requestHeaders,
                              const nsHttpAtom&          requestMethod,
+                             const PRUint16&            priority,
                              const PRUint8&             redirectionLimit,
                              const PRBool&              allowPipelining,
                              const PRBool&              forceAllowThirdPartyCookie);
+
+  virtual bool RecvSetPriority(const PRUint16& priority);
 };
 
 } // namespace net
 } // namespace mozilla
 
 #endif // mozilla_net_HttpChannelParent_h
--- a/netwerk/protocol/http/src/PHttpChannel.ipdl
+++ b/netwerk/protocol/http/src/PHttpChannel.ipdl
@@ -67,20 +67,23 @@ parent:
             nsCString           originalCharset, 
             nsCString           docUriSpec, 
             nsCString           docCharset, 
             nsCString           referrerSpec,
             nsCString           referrerCharset,
             PRUint32            loadFlags,
             RequestHeaderTuples requestHeaders,
             nsHttpAtom          requestMethod,
+            PRUint16            priority,
             PRUint8             redirectionLimit,
             PRBool              allowPipelining,
             PRBool              forceAllowThirdPartyCookie);
 
+  SetPriority(PRUint16 priority);
+
 child:
   OnStartRequest(nsHttpResponseHead responseHead);
 
   OnDataAvailable(nsCString data, 
                   PRUint32  offset, 
                   PRUint32  count);
 
   OnStopRequest(nsresult statusCode);
--- a/netwerk/protocol/http/src/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/src/nsHttpChannel.cpp
@@ -76,17 +76,16 @@
 static NS_DEFINE_CID(kStreamListenerTeeCID, NS_STREAMLISTENERTEE_CID);
 
 //-----------------------------------------------------------------------------
 // nsHttpChannel <public>
 //-----------------------------------------------------------------------------
 
 nsHttpChannel::nsHttpChannel()
     : mLogicalOffset(0)
-    , mPriority(PRIORITY_NORMAL)
     , mCacheAccess(0)
     , mPostID(0)
     , mRequestTime(0)
     , mProxyAuthContinuationState(nsnull)
     , mAuthContinuationState(nsnull)
     , mStartPos(LL_MAXUINT)
     , mPendingAsyncCallOnResume(nsnull)
     , mSuspendCount(0)
@@ -4328,40 +4327,27 @@ nsHttpChannel::GetContentEncodings(nsIUT
     return NS_OK;
 }
 
 //-----------------------------------------------------------------------------
 // nsHttpChannel::nsISupportsPriority
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
-nsHttpChannel::GetPriority(PRInt32 *value)
-{
-    *value = mPriority;
-    return NS_OK;
-}
-
-NS_IMETHODIMP
 nsHttpChannel::SetPriority(PRInt32 value)
 {
     PRInt16 newValue = CLAMP(value, PR_INT16_MIN, PR_INT16_MAX);
     if (mPriority == newValue)
         return NS_OK;
     mPriority = newValue;
     if (mTransaction)
         gHttpHandler->RescheduleTransaction(mTransaction, mPriority);
     return NS_OK;
 }
 
-NS_IMETHODIMP
-nsHttpChannel::AdjustPriority(PRInt32 delta)
-{
-    return SetPriority(mPriority + delta);
-}
-
 //-----------------------------------------------------------------------------
 // nsHttpChannel::nsIProtocolProxyCallback
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
 nsHttpChannel::OnProxyAvailable(nsICancelable *request, nsIURI *uri,
                                 nsIProxyInfo *pi, nsresult status)
 {
--- a/netwerk/protocol/http/src/nsHttpChannel.h
+++ b/netwerk/protocol/http/src/nsHttpChannel.h
@@ -56,17 +56,16 @@
 #include "nsIApplicationCache.h"
 #include "nsIApplicationCacheChannel.h"
 #include "nsIEncodedChannel.h"
 #include "nsIUploadChannel.h"
 #include "nsIUploadChannel2.h"
 #include "nsIStringEnumerator.h"
 #include "nsIPrompt.h"
 #include "nsIResumableChannel.h"
-#include "nsISupportsPriority.h"
 #include "nsIProtocolProxyCallback.h"
 #include "nsICancelable.h"
 #include "nsIProxiedChannel.h"
 #include "nsITraceableChannel.h"
 #include "nsIAuthPromptCallback.h"
 
 class nsAHttpConnection;
 class nsIHttpAuthenticator;
@@ -81,17 +80,16 @@ class nsHttpChannel : public HttpBaseCha
                     , public nsIStreamListener
                     , public nsICachingChannel
                     , public nsIUploadChannel
                     , public nsIUploadChannel2
                     , public nsICacheListener
                     , public nsIEncodedChannel
                     , public nsITransportEventSink
                     , public nsIResumableChannel
-                    , public nsISupportsPriority
                     , public nsIProtocolProxyCallback
                     , public nsIProxiedChannel
                     , public nsITraceableChannel
                     , public nsIApplicationCacheChannel
                     , public nsIAuthPromptCallback
 {
 public:
     NS_DECL_ISUPPORTS_INHERITED
@@ -99,17 +97,16 @@ public:
     NS_DECL_NSISTREAMLISTENER
     NS_DECL_NSICACHINGCHANNEL
     NS_DECL_NSIUPLOADCHANNEL
     NS_DECL_NSIUPLOADCHANNEL2
     NS_DECL_NSICACHELISTENER
     NS_DECL_NSIENCODEDCHANNEL
     NS_DECL_NSITRANSPORTEVENTSINK
     NS_DECL_NSIRESUMABLECHANNEL
-    NS_DECL_NSISUPPORTSPRIORITY
     NS_DECL_NSIPROTOCOLPROXYCALLBACK
     NS_DECL_NSIPROXIEDCHANNEL
     NS_DECL_NSITRACEABLECHANNEL
     NS_DECL_NSIAPPLICATIONCACHECONTAINER
     NS_DECL_NSIAPPLICATIONCACHECHANNEL
     NS_DECL_NSIAUTHPROMPTCALLBACK
 
     nsHttpChannel();
@@ -123,16 +120,18 @@ public:
     NS_IMETHOD Resume();
     // nsIChannel
     NS_IMETHOD GetOwner(nsISupports **aOwner);
     NS_IMETHOD SetOwner(nsISupports *aOwner);
     NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo);
     NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext);
     // nsIHttpChannelInternal
     NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey);
+    // nsISupportsPriority
+    NS_IMETHOD SetPriority(PRInt32 value);
 
 public: /* internal necko use only */ 
     typedef void (nsHttpChannel:: *nsAsyncCallback)(void);
     nsHttpResponseHead * GetResponseHead() const { return mResponseHead; }
 
     nsresult SetReferrerInternal(nsIURI *referrer) {
         nsCAutoString spec;
         nsresult rv = referrer->GetAsciiSpec(spec);
@@ -261,18 +260,16 @@ private:
     nsCOMPtr<nsIInputStream>          mUploadStream;
     nsCOMPtr<nsISupports>             mSecurityInfo;
     nsCOMPtr<nsICancelable>           mProxyRequest;
 
     nsRefPtr<nsInputStreamPump>       mTransactionPump;
     nsRefPtr<nsHttpTransaction>       mTransaction;
 
     PRUint64                          mLogicalOffset;
-    PRInt16                           mPriority;
-
     nsCString                         mUserSetCookieHeader;
 
     // cache specific data
     nsCOMPtr<nsICacheEntryDescriptor> mCacheEntry;
     nsRefPtr<nsInputStreamPump>       mCachePump;
     nsAutoPtr<nsHttpResponseHead>     mCachedResponseHead;
     nsCacheAccessMode                 mCacheAccess;
     PRUint32                          mPostID;