Add m-esr52 at 52.6.0

1 files changed, 620 insertions, 0 deletions

diff --git a/netwerk/protocol/http/nsHttpChannel.h b/netwerk/protocol/http/nsHttpChannel.h
new file mode 100644
index 000000000..ad8156ec0
--- /dev/null
+++ b/netwerk/protocol/http/nsHttpChannel.h
@@ -0,0 +1,620 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim:set et cin ts=4 sw=4 sts=4: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsHttpChannel_h__
+#define nsHttpChannel_h__
+
+#include "HttpBaseChannel.h"
+#include "nsTArray.h"
+#include "nsICachingChannel.h"
+#include "nsICacheEntry.h"
+#include "nsICacheEntryOpenCallback.h"
+#include "nsIDNSListener.h"
+#include "nsIApplicationCacheChannel.h"
+#include "nsIChannelWithDivertableParentListener.h"
+#include "nsIProtocolProxyCallback.h"
+#include "nsIHttpAuthenticableChannel.h"
+#include "nsIAsyncVerifyRedirectCallback.h"
+#include "nsIThreadRetargetableRequest.h"
+#include "nsIThreadRetargetableStreamListener.h"
+#include "nsWeakReference.h"
+#include "TimingStruct.h"
+#include "ADivertableParentChannel.h"
+#include "AutoClose.h"
+#include "nsIStreamListener.h"
+#include "nsISupportsPrimitives.h"
+#include "nsICorsPreflightCallback.h"
+#include "AlternateServices.h"
+#include "nsIHstsPrimingCallback.h"
+
+class nsDNSPrefetch;
+class nsICancelable;
+class nsIHttpChannelAuthProvider;
+class nsInputStreamPump;
+class nsISSLStatus;
+
+namespace mozilla { namespace net {
+
+class Http2PushedStream;
+
+class HttpChannelSecurityWarningReporter
+{
+public:
+  virtual nsresult ReportSecurityMessage(const nsAString& aMessageTag,
+                                         const nsAString& aMessageCategory) = 0;
+};
+
+//-----------------------------------------------------------------------------
+// nsHttpChannel
+//-----------------------------------------------------------------------------
+
+// Use to support QI nsIChannel to nsHttpChannel
+#define NS_HTTPCHANNEL_IID                         \
+{                                                  \
+  0x301bf95b,                                      \
+  0x7bb3,                                          \
+  0x4ae1,                                          \
+  {0xa9, 0x71, 0x40, 0xbc, 0xfa, 0x81, 0xde, 0x12} \
+}
+
+class nsHttpChannel final : public HttpBaseChannel
+                          , public HttpAsyncAborter<nsHttpChannel>
+                          , public nsIStreamListener
+                          , public nsICachingChannel
+                          , public nsICacheEntryOpenCallback
+                          , public nsITransportEventSink
+                          , public nsIProtocolProxyCallback
+                          , public nsIHttpAuthenticableChannel
+                          , public nsIApplicationCacheChannel
+                          , public nsIAsyncVerifyRedirectCallback
+                          , public nsIThreadRetargetableRequest
+                          , public nsIThreadRetargetableStreamListener
+                          , public nsIDNSListener
+                          , public nsSupportsWeakReference
+                          , public nsICorsPreflightCallback
+                          , public nsIChannelWithDivertableParentListener
+                          , public nsIHstsPrimingCallback
+{
+public:
+    NS_DECL_ISUPPORTS_INHERITED
+    NS_DECL_NSIREQUESTOBSERVER
+    NS_DECL_NSISTREAMLISTENER
+    NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
+    NS_DECL_NSICACHEINFOCHANNEL
+    NS_DECL_NSICACHINGCHANNEL
+    NS_DECL_NSICACHEENTRYOPENCALLBACK
+    NS_DECL_NSITRANSPORTEVENTSINK
+    NS_DECL_NSIPROTOCOLPROXYCALLBACK
+    NS_DECL_NSIPROXIEDCHANNEL
+    NS_DECL_NSIAPPLICATIONCACHECONTAINER
+    NS_DECL_NSIAPPLICATIONCACHECHANNEL
+    NS_DECL_NSIASYNCVERIFYREDIRECTCALLBACK
+    NS_DECL_NSIHSTSPRIMINGCALLBACK
+    NS_DECL_NSITHREADRETARGETABLEREQUEST
+    NS_DECL_NSIDNSLISTENER
+    NS_DECL_NSICHANNELWITHDIVERTABLEPARENTLISTENER
+    NS_DECLARE_STATIC_IID_ACCESSOR(NS_HTTPCHANNEL_IID)
+
+    // nsIHttpAuthenticableChannel. We can't use
+    // NS_DECL_NSIHTTPAUTHENTICABLECHANNEL because it duplicates cancel() and
+    // others.
+    NS_IMETHOD GetIsSSL(bool *aIsSSL) override;
+    NS_IMETHOD GetProxyMethodIsConnect(bool *aProxyMethodIsConnect) override;
+    NS_IMETHOD GetServerResponseHeader(nsACString & aServerResponseHeader) override;
+    NS_IMETHOD GetProxyChallenges(nsACString & aChallenges) override;
+    NS_IMETHOD GetWWWChallenges(nsACString & aChallenges) override;
+    NS_IMETHOD SetProxyCredentials(const nsACString & aCredentials) override;
+    NS_IMETHOD SetWWWCredentials(const nsACString & aCredentials) override;
+    NS_IMETHOD OnAuthAvailable() override;
+    NS_IMETHOD OnAuthCancelled(bool userCancel) override;
+    NS_IMETHOD CloseStickyConnection() override;
+    NS_IMETHOD ConnectionRestartable(bool) override;
+    // Functions we implement from nsIHttpAuthenticableChannel but are
+    // declared in HttpBaseChannel must be implemented in this class. We
+    // just call the HttpBaseChannel:: impls.
+    NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags) override;
+    NS_IMETHOD GetURI(nsIURI **aURI) override;
+    NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks) override;
+    NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup) override;
+    NS_IMETHOD GetRequestMethod(nsACString& aMethod) override;
+
+    nsHttpChannel();
+
+    virtual nsresult Init(nsIURI *aURI, uint32_t aCaps, nsProxyInfo *aProxyInfo,
+                          uint32_t aProxyResolveFlags,
+                          nsIURI *aProxyURI,
+                          const nsID& aChannelId) override;
+
+    nsresult OnPush(const nsACString &uri, Http2PushedStream *pushedStream);
+
+    static bool IsRedirectStatus(uint32_t status);
+
+
+    // Methods HttpBaseChannel didn't implement for us or that we override.
+    //
+    // nsIRequest
+    NS_IMETHOD Cancel(nsresult status) override;
+    NS_IMETHOD Suspend() override;
+    NS_IMETHOD Resume() override;
+    // nsIChannel
+    NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) override;
+    NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext) override;
+    NS_IMETHOD AsyncOpen2(nsIStreamListener *aListener) override;
+    // nsIHttpChannel
+    NS_IMETHOD GetEncodedBodySize(uint64_t *aEncodedBodySize) override;
+    // nsIHttpChannelInternal
+    NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey) override;
+    NS_IMETHOD ForceIntercepted(uint64_t aInterceptionID) override;
+    virtual mozilla::net::nsHttpChannel * QueryHttpChannelImpl(void) override;
+    // nsISupportsPriority
+    NS_IMETHOD SetPriority(int32_t value) override;
+    // nsIClassOfService
+    NS_IMETHOD SetClassFlags(uint32_t inFlags) override;
+    NS_IMETHOD AddClassFlags(uint32_t inFlags) override;
+    NS_IMETHOD ClearClassFlags(uint32_t inFlags) override;
+
+    // nsIResumableChannel
+    NS_IMETHOD ResumeAt(uint64_t startPos, const nsACString& entityID) override;
+
+    NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks) override;
+    NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup) override;
+    // nsITimedChannel
+    NS_IMETHOD GetDomainLookupStart(mozilla::TimeStamp *aDomainLookupStart) override;
+    NS_IMETHOD GetDomainLookupEnd(mozilla::TimeStamp *aDomainLookupEnd) override;
+    NS_IMETHOD GetConnectStart(mozilla::TimeStamp *aConnectStart) override;
+    NS_IMETHOD GetConnectEnd(mozilla::TimeStamp *aConnectEnd) override;
+    NS_IMETHOD GetRequestStart(mozilla::TimeStamp *aRequestStart) override;
+    NS_IMETHOD GetResponseStart(mozilla::TimeStamp *aResponseStart) override;
+    NS_IMETHOD GetResponseEnd(mozilla::TimeStamp *aResponseEnd) override;
+    // nsICorsPreflightCallback
+    NS_IMETHOD OnPreflightSucceeded() override;
+    NS_IMETHOD OnPreflightFailed(nsresult aError) override;
+
+    nsresult AddSecurityMessage(const nsAString& aMessageTag,
+                                const nsAString& aMessageCategory) override;
+
+    void SetWarningReporter(HttpChannelSecurityWarningReporter* aReporter)
+      { mWarningReporter = aReporter; }
+
+public: /* internal necko use only */
+
+    void InternalSetUploadStream(nsIInputStream *uploadStream)
+      { mUploadStream = uploadStream; }
+    void SetUploadStreamHasHeaders(bool hasHeaders)
+      { mUploadStreamHasHeaders = hasHeaders; }
+
+    nsresult SetReferrerWithPolicyInternal(nsIURI *referrer,
+                                           uint32_t referrerPolicy) {
+        nsAutoCString spec;
+        nsresult rv = referrer->GetAsciiSpec(spec);
+        if (NS_FAILED(rv)) return rv;
+        mReferrer = referrer;
+        mReferrerPolicy = referrerPolicy;
+        mRequestHead.SetHeader(nsHttp::Referer, spec);
+        return NS_OK;
+    }
+
+    nsresult SetTopWindowURI(nsIURI* aTopWindowURI) {
+        mTopWindowURI = aTopWindowURI;
+        return NS_OK;
+    }
+
+    uint32_t GetRequestTime() const
+    {
+        return mRequestTime;
+    }
+
+    nsresult OpenCacheEntry(bool usingSSL);
+    nsresult ContinueConnect();
+
+    // If the load is mixed-content, build and send an HSTS priming request.
+    nsresult TryHSTSPriming();
+
+    nsresult StartRedirectChannelToURI(nsIURI *, uint32_t);
+
+    // This allows cache entry to be marked as foreign even after channel itself
+    // is gone.  Needed for e10s (see HttpChannelParent::RecvDocumentChannelCleanup)
+    class OfflineCacheEntryAsForeignMarker {
+        nsCOMPtr<nsIApplicationCache> mApplicationCache;
+        nsCOMPtr<nsIURI> mCacheURI;
+    public:
+        OfflineCacheEntryAsForeignMarker(nsIApplicationCache* appCache,
+                                         nsIURI* aURI)
+             : mApplicationCache(appCache)
+             , mCacheURI(aURI)
+        {}
+
+        nsresult MarkAsForeign();
+    };
+
+    OfflineCacheEntryAsForeignMarker* GetOfflineCacheEntryAsForeignMarker();
+
+    // Helper to keep cache callbacks wait flags consistent
+    class AutoCacheWaitFlags
+    {
+    public:
+      explicit AutoCacheWaitFlags(nsHttpChannel* channel)
+        : mChannel(channel)
+        , mKeep(0)
+      {
+        // Flags must be set before entering any AsyncOpenCacheEntry call.
+        mChannel->mCacheEntriesToWaitFor =
+          nsHttpChannel::WAIT_FOR_CACHE_ENTRY |
+          nsHttpChannel::WAIT_FOR_OFFLINE_CACHE_ENTRY;
+      }
+
+      void Keep(uint32_t flags)
+      {
+        // Called after successful call to appropriate AsyncOpenCacheEntry call.
+        mKeep |= flags;
+      }
+
+      ~AutoCacheWaitFlags()
+      {
+        // Keep only flags those are left to be wait for.
+        mChannel->mCacheEntriesToWaitFor &= mKeep;
+      }
+
+    private:
+      nsHttpChannel* mChannel;
+      uint32_t mKeep : 2;
+    };
+
+    void MarkIntercepted();
+    NS_IMETHOD GetResponseSynthesized(bool* aSynthesized) override;
+    bool AwaitingCacheCallbacks();
+    void SetCouldBeSynthesized();
+
+private: // used for alternate service validation
+    RefPtr<TransactionObserver> mTransactionObserver;
+public:
+    void SetConnectionInfo(nsHttpConnectionInfo *); // clones the argument
+    void SetTransactionObserver(TransactionObserver *arg) { mTransactionObserver = arg; }
+    TransactionObserver *GetTransactionObserver() { return mTransactionObserver; }
+
+protected:
+    virtual ~nsHttpChannel();
+
+private:
+    typedef nsresult (nsHttpChannel::*nsContinueRedirectionFunc)(nsresult result);
+
+    bool     RequestIsConditional();
+    nsresult BeginConnect();
+    void     HandleBeginConnectContinue();
+    MOZ_MUST_USE nsresult BeginConnectContinue();
+    nsresult ContinueBeginConnectWithResult();
+    void     ContinueBeginConnect();
+    nsresult Connect();
+    void     SpeculativeConnect();
+    nsresult SetupTransaction();
+    void     SetupTransactionRequestContext();
+    nsresult CallOnStartRequest();
+    nsresult ProcessResponse();
+    void     AsyncContinueProcessResponse();
+    nsresult ContinueProcessResponse1();
+    nsresult ContinueProcessResponse2(nsresult);
+    nsresult ContinueProcessResponse3(nsresult);
+    nsresult ProcessNormal();
+    nsresult ContinueProcessNormal(nsresult);
+    void     ProcessAltService();
+    bool     ShouldBypassProcessNotModified();
+    nsresult ProcessNotModified();
+    nsresult AsyncProcessRedirection(uint32_t httpStatus);
+    nsresult ContinueProcessRedirection(nsresult);
+    nsresult ContinueProcessRedirectionAfterFallback(nsresult);
+    nsresult ProcessFailedProxyConnect(uint32_t httpStatus);
+    nsresult ProcessFallback(bool *waitingForRedirectCallback);
+    nsresult ContinueProcessFallback(nsresult);
+    void     HandleAsyncAbort();
+    nsresult EnsureAssocReq();
+    void     ProcessSSLInformation();
+    bool     IsHTTPS();
+
+    nsresult ContinueOnStartRequest1(nsresult);
+    nsresult ContinueOnStartRequest2(nsresult);
+    nsresult ContinueOnStartRequest3(nsresult);
+
+    // redirection specific methods
+    void     HandleAsyncRedirect();
+    void     HandleAsyncAPIRedirect();
+    nsresult ContinueHandleAsyncRedirect(nsresult);
+    void     HandleAsyncNotModified();
+    void     HandleAsyncFallback();
+    nsresult ContinueHandleAsyncFallback(nsresult);
+    nsresult PromptTempRedirect();
+    virtual  nsresult SetupReplacementChannel(nsIURI *, nsIChannel *,
+                                              bool preserveMethod,
+                                              uint32_t redirectFlags) override;
+
+    // proxy specific methods
+    nsresult ProxyFailover();
+    nsresult AsyncDoReplaceWithProxy(nsIProxyInfo *);
+    nsresult ContinueDoReplaceWithProxy(nsresult);
+    nsresult ResolveProxy();
+
+    // cache specific methods
+    nsresult OnOfflineCacheEntryAvailable(nsICacheEntry *aEntry,
+                                          bool aNew,
+                                          nsIApplicationCache* aAppCache,
+                                          nsresult aResult);
+    nsresult OnNormalCacheEntryAvailable(nsICacheEntry *aEntry,
+                                         bool aNew,
+                                         nsresult aResult);
+    nsresult OpenOfflineCacheEntryForWriting();
+    nsresult OnOfflineCacheEntryForWritingAvailable(nsICacheEntry *aEntry,
+                                                    nsIApplicationCache* aAppCache,
+                                                    nsresult aResult);
+    nsresult OnCacheEntryAvailableInternal(nsICacheEntry *entry,
+                                      bool aNew,
+                                      nsIApplicationCache* aAppCache,
+                                      nsresult status);
+    nsresult GenerateCacheKey(uint32_t postID, nsACString &key);
+    nsresult UpdateExpirationTime();
+    nsresult CheckPartial(nsICacheEntry* aEntry, int64_t *aSize, int64_t *aContentLength);
+    bool ShouldUpdateOfflineCacheEntry();
+    nsresult ReadFromCache(bool alreadyMarkedValid);
+    void     CloseCacheEntry(bool doomOnFailure);
+    void     CloseOfflineCacheEntry();
+    nsresult InitCacheEntry();
+    void     UpdateInhibitPersistentCachingFlag();
+    nsresult InitOfflineCacheEntry();
+    nsresult AddCacheEntryHeaders(nsICacheEntry *entry);
+    nsresult FinalizeCacheEntry();
+    nsresult InstallCacheListener(int64_t offset = 0);
+    nsresult InstallOfflineCacheListener(int64_t offset = 0);
+    void     MaybeInvalidateCacheEntryForSubsequentGet();
+    void     AsyncOnExamineCachedResponse();
+
+    // Handle the bogus Content-Encoding Apache sometimes sends
+    void ClearBogusContentEncodingIfNeeded();
+
+    // byte range request specific methods
+    nsresult ProcessPartialContent();
+    nsresult OnDoneReadingPartialCacheEntry(bool *streamDone);
+
+    nsresult DoAuthRetry(nsAHttpConnection *);
+
+    void     HandleAsyncRedirectChannelToHttps();
+    nsresult StartRedirectChannelToHttps();
+    nsresult ContinueAsyncRedirectChannelToURI(nsresult rv);
+    nsresult OpenRedirectChannel(nsresult rv);
+
+    /**
+     * A function that takes care of reading STS and PKP headers and enforcing
+     * STS and PKP load rules. After a secure channel is erected, STS and PKP
+     * requires the channel to be trusted or any STS or PKP header data on
+     * the channel is ignored. This is called from ProcessResponse.
+     */
+    nsresult ProcessSecurityHeaders();
+
+    /**
+     * Taking care of the Content-Signature header and fail the channel if
+     * the signature verification fails or is required but the header is not
+     * present.
+     * This sets mListener to ContentVerifier, which buffers the entire response
+     * before verifying the Content-Signature header. If the verification is
+     * successful, the load proceeds as usual. If the verification fails, a
+     * NS_ERROR_INVALID_SIGNATURE is thrown and a fallback loaded in nsDocShell
+     */
+    nsresult ProcessContentSignatureHeader(nsHttpResponseHead *aResponseHead);
+
+    /**
+     * A function that will, if the feature is enabled, send security reports.
+     */
+    void ProcessSecurityReport(nsresult status);
+
+    /**
+     * A function to process a single security header (STS or PKP), assumes
+     * some basic sanity checks have been applied to the channel. Called
+     * from ProcessSecurityHeaders.
+     */
+    nsresult ProcessSingleSecurityHeader(uint32_t aType,
+                                         nsISSLStatus *aSSLStatus,
+                                         uint32_t aFlags);
+
+    void InvalidateCacheEntryForLocation(const char *location);
+    void AssembleCacheKey(const char *spec, uint32_t postID, nsACString &key);
+    nsresult CreateNewURI(const char *loc, nsIURI **newURI);
+    void DoInvalidateCacheEntry(nsIURI* aURI);
+
+    // Ref RFC2616 13.10: "invalidation... MUST only be performed if
+    // the host part is the same as in the Request-URI"
+    inline bool HostPartIsTheSame(nsIURI *uri) {
+        nsAutoCString tmpHost1, tmpHost2;
+        return (NS_SUCCEEDED(mURI->GetAsciiHost(tmpHost1)) &&
+                NS_SUCCEEDED(uri->GetAsciiHost(tmpHost2)) &&
+                (tmpHost1 == tmpHost2));
+    }
+
+    inline static bool DoNotRender3xxBody(nsresult rv) {
+        return rv == NS_ERROR_REDIRECT_LOOP         ||
+               rv == NS_ERROR_CORRUPTED_CONTENT     ||
+               rv == NS_ERROR_UNKNOWN_PROTOCOL      ||
+               rv == NS_ERROR_MALFORMED_URI;
+    }
+
+    // Report net vs cache time telemetry
+    void ReportNetVSCacheTelemetry();
+
+    // Create a aggregate set of the current notification callbacks
+    // and ensure the transaction is updated to use it.
+    void UpdateAggregateCallbacks();
+
+    static bool HasQueryString(nsHttpRequestHead::ParsedMethodType method, nsIURI * uri);
+    bool ResponseWouldVary(nsICacheEntry* entry);
+    bool IsResumable(int64_t partialLen, int64_t contentLength,
+                     bool ignoreMissingPartialLen = false) const;
+    nsresult MaybeSetupByteRangeRequest(int64_t partialLen, int64_t contentLength,
+                                        bool ignoreMissingPartialLen = false);
+    nsresult SetupByteRangeRequest(int64_t partialLen);
+    void UntieByteRangeRequest();
+    void UntieValidationRequest();
+    nsresult OpenCacheInputStream(nsICacheEntry* cacheEntry, bool startBuffering,
+                                  bool checkingAppCacheEntry);
+
+    void SetPushedStream(Http2PushedStream *stream);
+
+    void MaybeWarnAboutAppCache();
+
+    void SetLoadGroupUserAgentOverride();
+
+    void SetDoNotTrack();
+
+private:
+    nsCOMPtr<nsICancelable>           mProxyRequest;
+
+    RefPtr<nsInputStreamPump>       mTransactionPump;
+    RefPtr<nsHttpTransaction>       mTransaction;
+
+    uint64_t                          mLogicalOffset;
+
+    // cache specific data
+    nsCOMPtr<nsICacheEntry>           mCacheEntry;
+    // This will be set during OnStopRequest() before calling CloseCacheEntry(),
+    // but only if the listener wants to use alt-data (signaled by
+    // HttpBaseChannel::mPreferredCachedAltDataType being not empty)
+    // Needed because calling openAlternativeOutputStream needs a reference
+    // to the cache entry.
+    nsCOMPtr<nsICacheEntry>           mAltDataCacheEntry;
+    // We must close mCacheInputStream explicitly to avoid leaks.
+    AutoClose<nsIInputStream>         mCacheInputStream;
+    RefPtr<nsInputStreamPump>       mCachePump;
+    nsAutoPtr<nsHttpResponseHead>     mCachedResponseHead;
+    nsCOMPtr<nsISupports>             mCachedSecurityInfo;
+    uint32_t                          mPostID;
+    uint32_t                          mRequestTime;
+
+    nsCOMPtr<nsICacheEntry> mOfflineCacheEntry;
+    uint32_t                          mOfflineCacheLastModifiedTime;
+    nsCOMPtr<nsIApplicationCache>     mApplicationCacheForWrite;
+
+    // auth specific data
+    nsCOMPtr<nsIHttpChannelAuthProvider> mAuthProvider;
+
+    mozilla::TimeStamp                mOnStartRequestTimestamp;
+
+    // States of channel interception
+    enum {
+        DO_NOT_INTERCEPT,  // no interception will occur
+        MAYBE_INTERCEPT,   // interception in progress, but can be cancelled
+        INTERCEPTED,       // a synthesized response has been provided
+    } mInterceptCache;
+    // ID of this channel for the interception purposes. Unique unless this
+    // channel is replacing an intercepted one via an redirection.
+    uint64_t mInterceptionID;
+
+    bool PossiblyIntercepted() {
+        return mInterceptCache != DO_NOT_INTERCEPT;
+    }
+
+    // If the channel is associated with a cache, and the URI matched
+    // a fallback namespace, this will hold the key for the fallback
+    // cache entry.
+    nsCString                         mFallbackKey;
+
+    friend class AutoRedirectVetoNotifier;
+    friend class HttpAsyncAborter<nsHttpChannel>;
+
+    nsCOMPtr<nsIURI>                  mRedirectURI;
+    nsCOMPtr<nsIChannel>              mRedirectChannel;
+    uint32_t                          mRedirectType;
+
+    static const uint32_t WAIT_FOR_CACHE_ENTRY = 1;
+    static const uint32_t WAIT_FOR_OFFLINE_CACHE_ENTRY = 2;
+
+    bool                              mCacheOpenWithPriority;
+    uint32_t                          mCacheQueueSizeWhenOpen;
+
+    // state flags
+    uint32_t                          mCachedContentIsValid     : 1;
+    uint32_t                          mCachedContentIsPartial   : 1;
+    uint32_t                          mCacheOnlyMetadata        : 1;
+    uint32_t                          mTransactionReplaced      : 1;
+    uint32_t                          mAuthRetryPending         : 1;
+    uint32_t                          mProxyAuthPending         : 1;
+    // Set if before the first authentication attempt a custom authorization
+    // header has been set on the channel.  This will make that custom header
+    // go to the server instead of any cached credentials.
+    uint32_t                          mCustomAuthHeader         : 1;
+    uint32_t                          mResuming                 : 1;
+    uint32_t                          mInitedCacheEntry         : 1;
+    // True if we are loading a fallback cache entry from the
+    // application cache.
+    uint32_t                          mFallbackChannel          : 1;
+    // True if consumer added its own If-None-Match or If-Modified-Since
+    // headers. In such a case we must not override them in the cache code
+    // and also we want to pass possible 304 code response through.
+    uint32_t                          mCustomConditionalRequest : 1;
+    uint32_t                          mFallingBack              : 1;
+    uint32_t                          mWaitingForRedirectCallback : 1;
+    // True if mRequestTime has been set. In such a case it is safe to update
+    // the cache entry's expiration time. Otherwise, it is not(see bug 567360).
+    uint32_t                          mRequestTimeInitialized : 1;
+    uint32_t                          mCacheEntryIsReadOnly : 1;
+    uint32_t                          mCacheEntryIsWriteOnly : 1;
+    // see WAIT_FOR_* constants above
+    uint32_t                          mCacheEntriesToWaitFor : 2;
+    uint32_t                          mHasQueryString : 1;
+    // whether cache entry data write was in progress during cache entry check
+    // when true, after we finish read from cache we must check all data
+    // had been loaded from cache. If not, then an error has to be propagated
+    // to the consumer.
+    uint32_t                          mConcurrentCacheAccess : 1;
+    // whether the request is setup be byte-range
+    uint32_t                          mIsPartialRequest : 1;
+    // true iff there is AutoRedirectVetoNotifier on the stack
+    uint32_t                          mHasAutoRedirectVetoNotifier : 1;
+    // consumers set this to true to use cache pinning, this has effect
+    // only when the channel is in an app context (load context has an appid)
+    uint32_t                          mPinCacheContent : 1;
+    // True if CORS preflight has been performed
+    uint32_t                          mIsCorsPreflightDone : 1;
+
+    // if the http transaction was performed (i.e. not cached) and
+    // the result in OnStopRequest was known to be correctly delimited
+    // by chunking, content-length, or h2 end-stream framing
+    uint32_t                          mStronglyFramed : 1;
+
+    // true if an HTTP transaction is created for the socket thread
+    uint32_t                          mUsedNetwork : 1;
+
+    // the next authentication request can be sent on a whole new connection
+    uint32_t                          mAuthConnectionRestartable : 1;
+
+    nsCOMPtr<nsIChannel>              mPreflightChannel;
+
+    nsTArray<nsContinueRedirectionFunc> mRedirectFuncStack;
+
+    // Needed for accurate DNS timing
+    RefPtr<nsDNSPrefetch>           mDNSPrefetch;
+
+    Http2PushedStream                 *mPushedStream;
+    // True if the channel's principal was found on a phishing, malware, or
+    // tracking (if tracking protection is enabled) blocklist
+    bool                              mLocalBlocklist;
+
+    nsresult WaitForRedirectCallback();
+    void PushRedirectAsyncFunc(nsContinueRedirectionFunc func);
+    void PopRedirectAsyncFunc(nsContinueRedirectionFunc func);
+
+    nsCString mUsername;
+
+    // If non-null, warnings should be reported to this object.
+    HttpChannelSecurityWarningReporter* mWarningReporter;
+
+    RefPtr<ADivertableParentChannel> mParentChannel;
+protected:
+    virtual void DoNotifyListenerCleanup() override;
+
+private: // cache telemetry
+    bool mDidReval;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(nsHttpChannel, NS_HTTPCHANNEL_IID)
+} // namespace net
+} // namespace mozilla
+
+#endif // nsHttpChannel_h__