summaryrefslogtreecommitdiffstats
path: root/netwerk/protocol/http/nsHttpChannel.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /netwerk/protocol/http/nsHttpChannel.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'netwerk/protocol/http/nsHttpChannel.h')
-rw-r--r--netwerk/protocol/http/nsHttpChannel.h620
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__