diff options
Diffstat (limited to 'netwerk/protocol/http/HttpBaseChannel.h')
| -rw-r--r-- | netwerk/protocol/http/HttpBaseChannel.h | 660 |
1 files changed, 660 insertions, 0 deletions
diff --git a/netwerk/protocol/http/HttpBaseChannel.h b/netwerk/protocol/http/HttpBaseChannel.h new file mode 100644 index 000000000..c8184a601 --- /dev/null +++ b/netwerk/protocol/http/HttpBaseChannel.h @@ -0,0 +1,660 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set sw=2 ts=8 et tw=80 : */ + +/* 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 mozilla_net_HttpBaseChannel_h +#define mozilla_net_HttpBaseChannel_h + +#include "nsHttp.h" +#include "nsAutoPtr.h" +#include "nsHashPropertyBag.h" +#include "nsProxyInfo.h" +#include "nsHttpRequestHead.h" +#include "nsHttpResponseHead.h" +#include "nsHttpConnectionInfo.h" +#include "nsIConsoleReportCollector.h" +#include "nsIEncodedChannel.h" +#include "nsIHttpChannel.h" +#include "nsHttpHandler.h" +#include "nsIHttpChannelInternal.h" +#include "nsIForcePendingChannel.h" +#include "nsIFormPOSTActionChannel.h" +#include "nsIUploadChannel2.h" +#include "nsIProgressEventSink.h" +#include "nsIURI.h" +#include "nsIEffectiveTLDService.h" +#include "nsIStringEnumerator.h" +#include "nsISupportsPriority.h" +#include "nsIClassOfService.h" +#include "nsIApplicationCache.h" +#include "nsIResumableChannel.h" +#include "nsITraceableChannel.h" +#include "nsILoadContext.h" +#include "nsILoadInfo.h" +#include "mozilla/net/NeckoCommon.h" +#include "nsThreadUtils.h" +#include "PrivateBrowsingChannel.h" +#include "mozilla/net/DNS.h" +#include "nsITimedChannel.h" +#include "nsIHttpChannel.h" +#include "nsISecurityConsoleMessage.h" +#include "nsCOMArray.h" +#include "mozilla/net/ChannelEventQueue.h" +#include "nsIThrottledInputChannel.h" + +class nsISecurityConsoleMessage; +class nsIPrincipal; + +namespace mozilla { + +namespace dom { +class Performance; +} + +class LogCollector; + +namespace net { +extern mozilla::LazyLogModule gHttpLog; + +/* + * This class is a partial implementation of nsIHttpChannel. It contains code + * 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 nsIEncodedChannel + , public nsIHttpChannel + , public nsIHttpChannelInternal + , public nsIFormPOSTActionChannel + , public nsIUploadChannel2 + , public nsISupportsPriority + , public nsIClassOfService + , public nsIResumableChannel + , public nsITraceableChannel + , public PrivateBrowsingChannel<HttpBaseChannel> + , public nsITimedChannel + , public nsIForcePendingChannel + , public nsIConsoleReportCollector + , public nsIThrottledInputChannel +{ +protected: + virtual ~HttpBaseChannel(); + +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIUPLOADCHANNEL + NS_DECL_NSIFORMPOSTACTIONCHANNEL + NS_DECL_NSIUPLOADCHANNEL2 + NS_DECL_NSITRACEABLECHANNEL + NS_DECL_NSITIMEDCHANNEL + NS_DECL_NSITHROTTLEDINPUTCHANNEL + + HttpBaseChannel(); + + virtual nsresult Init(nsIURI *aURI, uint32_t aCaps, nsProxyInfo *aProxyInfo, + uint32_t aProxyResolveFlags, + nsIURI *aProxyURI, + const nsID& aChannelId); + + // nsIRequest + NS_IMETHOD GetName(nsACString& aName) override; + NS_IMETHOD IsPending(bool *aIsPending) override; + NS_IMETHOD GetStatus(nsresult *aStatus) override; + NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup) override; + NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup) override; + NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags) override; + NS_IMETHOD SetLoadFlags(nsLoadFlags aLoadFlags) override; + NS_IMETHOD SetDocshellUserAgentOverride(); + + // nsIChannel + NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI) override; + NS_IMETHOD SetOriginalURI(nsIURI *aOriginalURI) override; + NS_IMETHOD GetURI(nsIURI **aURI) override; + NS_IMETHOD GetOwner(nsISupports **aOwner) override; + NS_IMETHOD SetOwner(nsISupports *aOwner) override; + NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo) override; + NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo) override; + NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks) override; + NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks) override; + NS_IMETHOD GetContentType(nsACString& aContentType) override; + NS_IMETHOD SetContentType(const nsACString& aContentType) override; + NS_IMETHOD GetContentCharset(nsACString& aContentCharset) override; + NS_IMETHOD SetContentCharset(const nsACString& aContentCharset) override; + NS_IMETHOD GetContentDisposition(uint32_t *aContentDisposition) override; + NS_IMETHOD SetContentDisposition(uint32_t aContentDisposition) override; + NS_IMETHOD GetContentDispositionFilename(nsAString& aContentDispositionFilename) override; + NS_IMETHOD SetContentDispositionFilename(const nsAString& aContentDispositionFilename) override; + NS_IMETHOD GetContentDispositionHeader(nsACString& aContentDispositionHeader) override; + NS_IMETHOD GetContentLength(int64_t *aContentLength) override; + NS_IMETHOD SetContentLength(int64_t aContentLength) override; + NS_IMETHOD Open(nsIInputStream **aResult) override; + NS_IMETHOD Open2(nsIInputStream **aResult) override; + NS_IMETHOD GetBlockAuthPrompt(bool* aValue) override; + NS_IMETHOD SetBlockAuthPrompt(bool aValue) override; + + // nsIEncodedChannel + NS_IMETHOD GetApplyConversion(bool *value) override; + NS_IMETHOD SetApplyConversion(bool value) override; + NS_IMETHOD GetContentEncodings(nsIUTF8StringEnumerator** aEncodings) override; + NS_IMETHOD DoApplyContentConversions(nsIStreamListener *aNextListener, + nsIStreamListener **aNewNextListener, + nsISupports *aCtxt) override; + + // HttpBaseChannel::nsIHttpChannel + NS_IMETHOD GetRequestMethod(nsACString& aMethod) override; + NS_IMETHOD SetRequestMethod(const nsACString& aMethod) override; + NS_IMETHOD GetReferrer(nsIURI **referrer) override; + NS_IMETHOD SetReferrer(nsIURI *referrer) override; + NS_IMETHOD GetReferrerPolicy(uint32_t *referrerPolicy) override; + NS_IMETHOD SetReferrerWithPolicy(nsIURI *referrer, uint32_t referrerPolicy) override; + NS_IMETHOD GetRequestHeader(const nsACString& aHeader, nsACString& aValue) override; + NS_IMETHOD SetRequestHeader(const nsACString& aHeader, + const nsACString& aValue, bool aMerge) override; + NS_IMETHOD SetEmptyRequestHeader(const nsACString& aHeader) override; + NS_IMETHOD VisitRequestHeaders(nsIHttpHeaderVisitor *visitor) override; + NS_IMETHOD VisitNonDefaultRequestHeaders(nsIHttpHeaderVisitor *visitor) override; + NS_IMETHOD GetResponseHeader(const nsACString &header, nsACString &value) override; + NS_IMETHOD SetResponseHeader(const nsACString& header, + const nsACString& value, bool merge) override; + NS_IMETHOD VisitResponseHeaders(nsIHttpHeaderVisitor *visitor) override; + NS_IMETHOD GetOriginalResponseHeader(const nsACString &aHeader, + nsIHttpHeaderVisitor *aVisitor) override; + NS_IMETHOD VisitOriginalResponseHeaders(nsIHttpHeaderVisitor *aVisitor) override; + NS_IMETHOD GetAllowPipelining(bool *value) override; + NS_IMETHOD SetAllowPipelining(bool value) override; + NS_IMETHOD GetAllowSTS(bool *value) override; + NS_IMETHOD SetAllowSTS(bool value) override; + NS_IMETHOD GetRedirectionLimit(uint32_t *value) override; + NS_IMETHOD SetRedirectionLimit(uint32_t value) override; + NS_IMETHOD IsNoStoreResponse(bool *value) override; + NS_IMETHOD IsNoCacheResponse(bool *value) override; + NS_IMETHOD IsPrivateResponse(bool *value) override; + NS_IMETHOD GetResponseStatus(uint32_t *aValue) override; + NS_IMETHOD GetResponseStatusText(nsACString& aValue) override; + NS_IMETHOD GetRequestSucceeded(bool *aValue) override; + NS_IMETHOD RedirectTo(nsIURI *newURI) override; + NS_IMETHOD GetRequestContextID(nsID *aRCID) override; + NS_IMETHOD GetTransferSize(uint64_t *aTransferSize) override; + NS_IMETHOD GetDecodedBodySize(uint64_t *aDecodedBodySize) override; + NS_IMETHOD GetEncodedBodySize(uint64_t *aEncodedBodySize) override; + NS_IMETHOD SetRequestContextID(const nsID aRCID) override; + NS_IMETHOD GetIsMainDocumentChannel(bool* aValue) override; + NS_IMETHOD SetIsMainDocumentChannel(bool aValue) override; + NS_IMETHOD GetProtocolVersion(nsACString & aProtocolVersion) override; + NS_IMETHOD GetChannelId(nsACString& aChannelId) override; + NS_IMETHOD SetChannelId(const nsACString& aChannelId) override; + NS_IMETHOD GetTopLevelContentWindowId(uint64_t *aContentWindowId) override; + NS_IMETHOD SetTopLevelContentWindowId(uint64_t aContentWindowId) override; + + // nsIHttpChannelInternal + NS_IMETHOD GetDocumentURI(nsIURI **aDocumentURI) override; + NS_IMETHOD SetDocumentURI(nsIURI *aDocumentURI) override; + NS_IMETHOD GetRequestVersion(uint32_t *major, uint32_t *minor) override; + NS_IMETHOD GetResponseVersion(uint32_t *major, uint32_t *minor) override; + NS_IMETHOD SetCookie(const char *aCookieHeader) override; + NS_IMETHOD GetThirdPartyFlags(uint32_t *aForce) override; + NS_IMETHOD SetThirdPartyFlags(uint32_t aForce) override; + NS_IMETHOD GetForceAllowThirdPartyCookie(bool *aForce) override; + NS_IMETHOD SetForceAllowThirdPartyCookie(bool aForce) override; + NS_IMETHOD GetCanceled(bool *aCanceled) override; + NS_IMETHOD GetChannelIsForDownload(bool *aChannelIsForDownload) override; + NS_IMETHOD SetChannelIsForDownload(bool aChannelIsForDownload) override; + NS_IMETHOD SetCacheKeysRedirectChain(nsTArray<nsCString> *cacheKeys) override; + NS_IMETHOD GetLocalAddress(nsACString& addr) override; + NS_IMETHOD GetLocalPort(int32_t* port) override; + NS_IMETHOD GetRemoteAddress(nsACString& addr) override; + NS_IMETHOD GetRemotePort(int32_t* port) override; + NS_IMETHOD GetAllowSpdy(bool *aAllowSpdy) override; + NS_IMETHOD SetAllowSpdy(bool aAllowSpdy) override; + NS_IMETHOD GetAllowAltSvc(bool *aAllowAltSvc) override; + NS_IMETHOD SetAllowAltSvc(bool aAllowAltSvc) override; + NS_IMETHOD GetBeConservative(bool *aBeConservative) override; + NS_IMETHOD SetBeConservative(bool aBeConservative) override; + NS_IMETHOD GetApiRedirectToURI(nsIURI * *aApiRedirectToURI) override; + virtual nsresult AddSecurityMessage(const nsAString &aMessageTag, const nsAString &aMessageCategory); + NS_IMETHOD TakeAllSecurityMessages(nsCOMArray<nsISecurityConsoleMessage> &aMessages) override; + NS_IMETHOD GetResponseTimeoutEnabled(bool *aEnable) override; + NS_IMETHOD SetResponseTimeoutEnabled(bool aEnable) override; + NS_IMETHOD GetInitialRwin(uint32_t* aRwin) override; + NS_IMETHOD SetInitialRwin(uint32_t aRwin) override; + NS_IMETHOD GetNetworkInterfaceId(nsACString& aNetworkInterfaceId) override; + NS_IMETHOD SetNetworkInterfaceId(const nsACString& aNetworkInterfaceId) override; + NS_IMETHOD ForcePending(bool aForcePending) override; + NS_IMETHOD GetLastModifiedTime(PRTime* lastModifiedTime) override; + NS_IMETHOD GetCorsIncludeCredentials(bool* aInclude) override; + NS_IMETHOD SetCorsIncludeCredentials(bool aInclude) override; + NS_IMETHOD GetCorsMode(uint32_t* aCorsMode) override; + NS_IMETHOD SetCorsMode(uint32_t aCorsMode) override; + NS_IMETHOD GetRedirectMode(uint32_t* aRedirectMode) override; + NS_IMETHOD SetRedirectMode(uint32_t aRedirectMode) override; + NS_IMETHOD GetFetchCacheMode(uint32_t* aFetchCacheMode) override; + NS_IMETHOD SetFetchCacheMode(uint32_t aFetchCacheMode) override; + NS_IMETHOD GetTopWindowURI(nsIURI **aTopWindowURI) override; + NS_IMETHOD GetProxyURI(nsIURI **proxyURI) override; + virtual void SetCorsPreflightParameters(const nsTArray<nsCString>& unsafeHeaders) override; + NS_IMETHOD GetConnectionInfoHashKey(nsACString& aConnectionInfoHashKey) override; + NS_IMETHOD GetIntegrityMetadata(nsAString& aIntegrityMetadata) override; + NS_IMETHOD SetIntegrityMetadata(const nsAString& aIntegrityMetadata) override; + virtual mozilla::net::nsHttpChannel * QueryHttpChannelImpl(void) override; + + inline void CleanRedirectCacheChainIfNecessary() + { + mRedirectedCachekeys = nullptr; + } + NS_IMETHOD HTTPUpgrade(const nsACString & aProtocolName, + nsIHttpUpgradeListener *aListener) override; + + // nsISupportsPriority + NS_IMETHOD GetPriority(int32_t *value) override; + NS_IMETHOD AdjustPriority(int32_t delta) override; + + // nsIClassOfService + NS_IMETHOD GetClassFlags(uint32_t *outFlags) override { *outFlags = mClassOfService; return NS_OK; } + + // nsIResumableChannel + NS_IMETHOD GetEntityID(nsACString& aEntityID) override; + + + // nsIConsoleReportCollector + void + AddConsoleReport(uint32_t aErrorFlags, const nsACString& aCategory, + nsContentUtils::PropertiesFile aPropertiesFile, + const nsACString& aSourceFileURI, + uint32_t aLineNumber, uint32_t aColumnNumber, + const nsACString& aMessageName, + const nsTArray<nsString>& aStringParams) override; + + void + FlushConsoleReports(nsIDocument* aDocument, + ReportAction aAction = ReportAction::Forget) override; + + void + FlushConsoleReports(nsIConsoleReportCollector* aCollector) override; + + void + FlushReportsByWindowId(uint64_t aWindowId, + ReportAction aAction = ReportAction::Forget) override; + + void + ClearConsoleReports() override; + + class nsContentEncodings : public nsIUTF8StringEnumerator + { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIUTF8STRINGENUMERATOR + + nsContentEncodings(nsIHttpChannel* aChannel, const char* aEncodingHeader); + + private: + virtual ~nsContentEncodings(); + + nsresult PrepareForNext(void); + + // We do not own the buffer. The channel owns it. + const char* mEncodingHeader; + const char* mCurStart; // points to start of current header + const char* mCurEnd; // points to end of current header + + // Hold a ref to our channel so that it can't go away and take the + // header with it. + nsCOMPtr<nsIHttpChannel> mChannel; + + bool mReady; + }; + + nsHttpResponseHead * GetResponseHead() const { return mResponseHead; } + nsHttpRequestHead * GetRequestHead() { return &mRequestHead; } + + const NetAddr& GetSelfAddr() { return mSelfAddr; } + const NetAddr& GetPeerAddr() { return mPeerAddr; } + + nsresult OverrideSecurityInfo(nsISupports* aSecurityInfo); + +public: /* Necko internal use only... */ + bool IsNavigation(); + + // Return whether upon a redirect code of httpStatus for method, the + // request method should be rewritten to GET. + static bool ShouldRewriteRedirectToGET(uint32_t httpStatus, + nsHttpRequestHead::ParsedMethodType method); + + // Like nsIEncodedChannel::DoApplyConversions except context is set to + // mListenerContext. + nsresult DoApplyContentConversions(nsIStreamListener *aNextListener, + nsIStreamListener **aNewNextListener); + + // Callback on main thread when NS_AsyncCopy() is finished populating + // the new mUploadStream. + void EnsureUploadStreamIsCloneableComplete(nsresult aStatus); + +protected: + nsCOMArray<nsISecurityConsoleMessage> mSecurityConsoleMessages; + + // Handle notifying listener, removing from loadgroup if request failed. + void DoNotifyListener(); + virtual void DoNotifyListenerCleanup() = 0; + + // drop reference to listener, its callbacks, and the progress sink + void ReleaseListeners(); + + // This is fired only when a cookie is created due to the presence of + // Set-Cookie header in the response header of any network request. + // This notification will come only after the "http-on-examine-response" + // was fired. + void NotifySetCookie(char const *aCookie); + + mozilla::dom::Performance* GetPerformance(); + nsIURI* GetReferringPage(); + nsPIDOMWindowInner* GetInnerDOMWindow(); + + void AddCookiesToRequest(); + virtual nsresult SetupReplacementChannel(nsIURI *, + nsIChannel *, + bool preserveMethod, + uint32_t redirectFlags); + + // bundle calling OMR observers and marking flag into one function + inline void CallOnModifyRequestObservers() { + gHttpHandler->OnModifyRequest(this); + mRequestObserversCalled = true; + } + + // Helper function to simplify getting notification callbacks. + template <class T> + void GetCallback(nsCOMPtr<T> &aResult) + { + NS_QueryNotificationCallbacks(mCallbacks, mLoadGroup, + NS_GET_TEMPLATE_IID(T), + getter_AddRefs(aResult)); + } + + // Redirect tracking + // Checks whether or not aURI and mOriginalURI share the same domain. + bool SameOriginWithOriginalUri(nsIURI *aURI); + + // GetPrincipal Returns the channel's URI principal. + nsIPrincipal *GetURIPrincipal(); + + bool BypassServiceWorker() const; + + // Returns true if this channel should intercept the network request and prepare + // for a possible synthesized response instead. + bool ShouldIntercept(nsIURI* aURI = nullptr); + +#ifdef DEBUG + // Check if mPrivateBrowsingId matches between LoadInfo and LoadContext. + void AssertPrivateBrowsingId(); +#endif + + friend class PrivateBrowsingChannel<HttpBaseChannel>; + friend class InterceptFailedOnStop; + + nsCOMPtr<nsIURI> mURI; + nsCOMPtr<nsIURI> mOriginalURI; + nsCOMPtr<nsIURI> mDocumentURI; + nsCOMPtr<nsIStreamListener> mListener; + nsCOMPtr<nsISupports> mListenerContext; + nsCOMPtr<nsILoadGroup> mLoadGroup; + nsCOMPtr<nsISupports> mOwner; + nsCOMPtr<nsILoadInfo> mLoadInfo; + nsCOMPtr<nsIInterfaceRequestor> mCallbacks; + nsCOMPtr<nsIProgressEventSink> mProgressSink; + nsCOMPtr<nsIURI> mReferrer; + nsCOMPtr<nsIApplicationCache> mApplicationCache; + + // An instance of nsHTTPCompressConv + nsCOMPtr<nsIStreamListener> mCompressListener; + + nsHttpRequestHead mRequestHead; + // Upload throttling. + nsCOMPtr<nsIInputChannelThrottleQueue> mThrottleQueue; + nsCOMPtr<nsIInputStream> mUploadStream; + nsCOMPtr<nsIRunnable> mUploadCloneableCallback; + nsAutoPtr<nsHttpResponseHead> mResponseHead; + RefPtr<nsHttpConnectionInfo> mConnectionInfo; + nsCOMPtr<nsIProxyInfo> mProxyInfo; + nsCOMPtr<nsISupports> mSecurityInfo; + + nsCString mSpec; // ASCII encoded URL spec + nsCString mContentTypeHint; + nsCString mContentCharsetHint; + nsCString mUserSetCookieHeader; + + NetAddr mSelfAddr; + NetAddr mPeerAddr; + + // HTTP Upgrade Data + nsCString mUpgradeProtocol; + nsCOMPtr<nsIHttpUpgradeListener> mUpgradeProtocolCallback; + + // Resumable channel specific data + nsCString mEntityID; + uint64_t mStartPos; + + nsresult mStatus; + uint32_t mLoadFlags; + uint32_t mCaps; + uint32_t mClassOfService; + int16_t mPriority; + uint8_t mRedirectionLimit; + + uint32_t mApplyConversion : 1; + uint32_t mCanceled : 1; + uint32_t mIsPending : 1; + uint32_t mWasOpened : 1; + // if 1 all "http-on-{opening|modify|etc}-request" observers have been called + uint32_t mRequestObserversCalled : 1; + uint32_t mResponseHeadersModified : 1; + uint32_t mAllowPipelining : 1; + uint32_t mAllowSTS : 1; + uint32_t mThirdPartyFlags : 3; + uint32_t mUploadStreamHasHeaders : 1; + uint32_t mInheritApplicationCache : 1; + uint32_t mChooseApplicationCache : 1; + uint32_t mLoadedFromApplicationCache : 1; + uint32_t mChannelIsForDownload : 1; + uint32_t mTracingEnabled : 1; + // True if timing collection is enabled + uint32_t mTimingEnabled : 1; + uint32_t mAllowSpdy : 1; + uint32_t mAllowAltSvc : 1; + uint32_t mBeConservative : 1; + uint32_t mResponseTimeoutEnabled : 1; + // A flag that should be false only if a cross-domain redirect occurred + uint32_t mAllRedirectsSameOrigin : 1; + + // Is 1 if no redirects have occured or if all redirects + // pass the Resource Timing timing-allow-check + uint32_t mAllRedirectsPassTimingAllowCheck : 1; + + // True if this channel was intercepted and could receive a synthesized response. + uint32_t mResponseCouldBeSynthesized : 1; + + uint32_t mBlockAuthPrompt : 1; + + // If true, we behave as if the LOAD_FROM_CACHE flag has been set. + // Used to enforce that flag's behavior but not expose it externally. + uint32_t mAllowStaleCacheContent : 1; + + // Current suspension depth for this channel object + uint32_t mSuspendCount; + + // Per channel transport window override (0 means no override) + uint32_t mInitialRwin; + + nsCOMPtr<nsIURI> mAPIRedirectToURI; + nsAutoPtr<nsTArray<nsCString> > mRedirectedCachekeys; + + uint32_t mProxyResolveFlags; + nsCOMPtr<nsIURI> mProxyURI; + + uint32_t mContentDispositionHint; + nsAutoPtr<nsString> mContentDispositionFilename; + + RefPtr<nsHttpHandler> mHttpHandler; // keep gHttpHandler alive + + uint32_t mReferrerPolicy; + + // Performance tracking + // The initiator type (for this resource) - how was the resource referenced in + // the HTML file. + nsString mInitiatorType; + // Number of redirects that has occurred. + int16_t mRedirectCount; + // A time value equal to the starting time of the fetch that initiates the + // redirect. + mozilla::TimeStamp mRedirectStartTimeStamp; + // A time value equal to the time immediately after receiving the last byte of + // the response of the last redirect. + mozilla::TimeStamp mRedirectEndTimeStamp; + + PRTime mChannelCreationTime; + TimeStamp mChannelCreationTimestamp; + TimeStamp mAsyncOpenTime; + TimeStamp mCacheReadStart; + TimeStamp mCacheReadEnd; + // copied from the transaction before we null out mTransaction + // so that the timing can still be queried from OnStopRequest + TimingStruct mTransactionTimings; + + nsCOMPtr<nsIPrincipal> mPrincipal; + + bool mForcePending; + nsCOMPtr<nsIURI> mTopWindowURI; + + bool mCorsIncludeCredentials; + uint32_t mCorsMode; + uint32_t mRedirectMode; + uint32_t mFetchCacheMode; + + // These parameters are used to ensure that we do not call OnStartRequest and + // OnStopRequest more than once. + bool mOnStartRequestCalled; + bool mOnStopRequestCalled; + + // Defaults to false. Is set to true at the begining of OnStartRequest. + // Used to ensure methods can't be called before OnStartRequest. + bool mAfterOnStartRequestBegun; + + uint64_t mTransferSize; + uint64_t mDecodedBodySize; + uint64_t mEncodedBodySize; + + // The network interface id that's associated with this channel. + nsCString mNetworkInterfaceId; + + nsID mRequestContextID; + bool EnsureRequestContextID(); + + // ID of the top-level document's inner window this channel is being + // originated from. + uint64_t mContentWindowId; + + bool mRequireCORSPreflight; + nsTArray<nsCString> mUnsafeHeaders; + + nsCOMPtr<nsIConsoleReportCollector> mReportCollector; + + // Holds the name of the preferred alt-data type. + nsCString mPreferredCachedAltDataType; + // Holds the name of the alternative data type the channel returned. + nsCString mAvailableCachedAltDataType; + + bool mForceMainDocumentChannel; + + nsID mChannelId; + + nsString mIntegrityMetadata; +}; + +// Share some code while working around C++'s absurd inability to handle casting +// of member functions between base/derived types. +// - We want to store member function pointer to call at resume time, but one +// such function--HandleAsyncAbort--we want to share between the +// nsHttpChannel/HttpChannelChild. Can't define it in base class, because +// then we'd have to cast member function ptr between base/derived class +// types. Sigh... +template <class T> +class HttpAsyncAborter +{ +public: + explicit HttpAsyncAborter(T *derived) : mThis(derived), mCallOnResume(0) {} + + // Aborts channel: calls OnStart/Stop with provided status, removes channel + // from loadGroup. + nsresult AsyncAbort(nsresult status); + + // Does most the actual work. + void HandleAsyncAbort(); + + // AsyncCall calls a member function asynchronously (via an event). + // retval isn't refcounted and is set only when event was successfully + // posted, the event is returned for the purpose of cancelling when needed + nsresult AsyncCall(void (T::*funcPtr)(), + nsRunnableMethod<T> **retval = nullptr); +private: + T *mThis; + +protected: + // Function to be called at resume time + void (T::* mCallOnResume)(void); +}; + +template <class T> +nsresult HttpAsyncAborter<T>::AsyncAbort(nsresult status) +{ + MOZ_LOG(gHttpLog, LogLevel::Debug, + ("HttpAsyncAborter::AsyncAbort [this=%p status=%x]\n", mThis, status)); + + mThis->mStatus = status; + + // if this fails? Callers ignore our return value anyway.... + return AsyncCall(&T::HandleAsyncAbort); +} + +// Each subclass needs to define its own version of this (which just calls this +// base version), else we wind up casting base/derived member function ptrs +template <class T> +inline void HttpAsyncAborter<T>::HandleAsyncAbort() +{ + NS_PRECONDITION(!mCallOnResume, "How did that happen?"); + + if (mThis->mSuspendCount) { + MOZ_LOG(gHttpLog, LogLevel::Debug, + ("Waiting until resume to do async notification [this=%p]\n", mThis)); + mCallOnResume = &T::HandleAsyncAbort; + return; + } + + mThis->DoNotifyListener(); + + // finally remove ourselves from the load group. + if (mThis->mLoadGroup) + mThis->mLoadGroup->RemoveRequest(mThis, nullptr, mThis->mStatus); +} + +template <class T> +nsresult HttpAsyncAborter<T>::AsyncCall(void (T::*funcPtr)(), + nsRunnableMethod<T> **retval) +{ + nsresult rv; + + RefPtr<nsRunnableMethod<T>> event = NewRunnableMethod(mThis, funcPtr); + rv = NS_DispatchToCurrentThread(event); + if (NS_SUCCEEDED(rv) && retval) { + *retval = event; + } + + return rv; +} + +} // namespace net +} // namespace mozilla + +#endif // mozilla_net_HttpBaseChannel_h |