diff options
Diffstat (limited to 'netwerk/protocol/http/nsHttpHandler.h')
| -rw-r--r-- | netwerk/protocol/http/nsHttpHandler.h | 683 |
1 files changed, 683 insertions, 0 deletions
diff --git a/netwerk/protocol/http/nsHttpHandler.h b/netwerk/protocol/http/nsHttpHandler.h new file mode 100644 index 000000000..13cc72e8e --- /dev/null +++ b/netwerk/protocol/http/nsHttpHandler.h @@ -0,0 +1,683 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 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 nsHttpHandler_h__ +#define nsHttpHandler_h__ + +#include "nsHttp.h" +#include "nsHttpAuthCache.h" +#include "nsHttpConnectionMgr.h" +#include "ASpdySession.h" + +#include "nsString.h" +#include "nsCOMPtr.h" +#include "nsWeakReference.h" + +#include "nsIHttpProtocolHandler.h" +#include "nsIObserver.h" +#include "nsISpeculativeConnect.h" + +class nsIHttpChannel; +class nsIPrefBranch; +class nsICancelable; +class nsICookieService; +class nsIIOService; +class nsIRequestContextService; +class nsISiteSecurityService; +class nsIStreamConverterService; +class nsITimer; +class nsIUUIDGenerator; + + +namespace mozilla { +namespace net { + +extern Atomic<PRThread*, Relaxed> gSocketThread; + +class ATokenBucketEvent; +class EventTokenBucket; +class Tickler; +class nsHttpConnection; +class nsHttpConnectionInfo; +class nsHttpTransaction; +class AltSvcMapping; + +enum FrameCheckLevel { + FRAMECHECK_LAX, + FRAMECHECK_BARELY, + FRAMECHECK_STRICT +}; + +//----------------------------------------------------------------------------- +// nsHttpHandler - protocol handler for HTTP and HTTPS +//----------------------------------------------------------------------------- + +class nsHttpHandler final : public nsIHttpProtocolHandler + , public nsIObserver + , public nsSupportsWeakReference + , public nsISpeculativeConnect +{ +public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIPROTOCOLHANDLER + NS_DECL_NSIPROXIEDPROTOCOLHANDLER + NS_DECL_NSIHTTPPROTOCOLHANDLER + NS_DECL_NSIOBSERVER + NS_DECL_NSISPECULATIVECONNECT + + nsHttpHandler(); + + nsresult Init(); + nsresult AddStandardRequestHeaders(nsHttpRequestHead *, bool isSecure); + nsresult AddConnectionHeader(nsHttpRequestHead *, + uint32_t capabilities); + bool IsAcceptableEncoding(const char *encoding, bool isSecure); + + const nsAFlatCString &UserAgent(); + + nsHttpVersion HttpVersion() { return mHttpVersion; } + nsHttpVersion ProxyHttpVersion() { return mProxyHttpVersion; } + uint8_t ReferrerLevel() { return mReferrerLevel; } + bool SpoofReferrerSource() { return mSpoofReferrerSource; } + uint8_t ReferrerTrimmingPolicy() { return mReferrerTrimmingPolicy; } + uint8_t ReferrerXOriginTrimmingPolicy() { + return mReferrerXOriginTrimmingPolicy; + } + uint8_t ReferrerXOriginPolicy() { return mReferrerXOriginPolicy; } + uint8_t RedirectionLimit() { return mRedirectionLimit; } + PRIntervalTime IdleTimeout() { return mIdleTimeout; } + PRIntervalTime SpdyTimeout() { return mSpdyTimeout; } + PRIntervalTime ResponseTimeout() { + return mResponseTimeoutEnabled ? mResponseTimeout : 0; + } + PRIntervalTime ResponseTimeoutEnabled() { return mResponseTimeoutEnabled; } + uint32_t NetworkChangedTimeout() { return mNetworkChangedTimeout; } + uint16_t MaxRequestAttempts() { return mMaxRequestAttempts; } + const char *DefaultSocketType() { return mDefaultSocketType.get(); /* ok to return null */ } + uint32_t PhishyUserPassLength() { return mPhishyUserPassLength; } + uint8_t GetQoSBits() { return mQoSBits; } + uint16_t GetIdleSynTimeout() { return mIdleSynTimeout; } + bool FastFallbackToIPv4() { return mFastFallbackToIPv4; } + bool ProxyPipelining() { return mProxyPipelining; } + uint32_t MaxSocketCount(); + bool EnforceAssocReq() { return mEnforceAssocReq; } + + bool IsPersistentHttpsCachingEnabled() { return mEnablePersistentHttpsCaching; } + bool IsTelemetryEnabled() { return mTelemetryEnabled; } + bool AllowExperiments() { return mTelemetryEnabled && mAllowExperiments; } + + bool IsSpdyEnabled() { return mEnableSpdy; } + bool IsHttp2Enabled() { return mHttp2Enabled; } + bool EnforceHttp2TlsProfile() { return mEnforceHttp2TlsProfile; } + bool CoalesceSpdy() { return mCoalesceSpdy; } + bool UseSpdyPersistentSettings() { return mSpdyPersistentSettings; } + uint32_t SpdySendingChunkSize() { return mSpdySendingChunkSize; } + uint32_t SpdySendBufferSize() { return mSpdySendBufferSize; } + uint32_t SpdyPushAllowance() { return mSpdyPushAllowance; } + uint32_t SpdyPullAllowance() { return mSpdyPullAllowance; } + uint32_t DefaultSpdyConcurrent() { return mDefaultSpdyConcurrent; } + PRIntervalTime SpdyPingThreshold() { return mSpdyPingThreshold; } + PRIntervalTime SpdyPingTimeout() { return mSpdyPingTimeout; } + bool AllowPush() { return mAllowPush; } + bool AllowAltSvc() { return mEnableAltSvc; } + bool AllowAltSvcOE() { return mEnableAltSvcOE; } + uint32_t ConnectTimeout() { return mConnectTimeout; } + uint32_t ParallelSpeculativeConnectLimit() { return mParallelSpeculativeConnectLimit; } + bool CriticalRequestPrioritization() { return mCriticalRequestPrioritization; } + bool UseH2Deps() { return mUseH2Deps; } + + uint32_t MaxConnectionsPerOrigin() { return mMaxPersistentConnectionsPerServer; } + bool UseRequestTokenBucket() { return mRequestTokenBucketEnabled; } + uint16_t RequestTokenBucketMinParallelism() { return mRequestTokenBucketMinParallelism; } + uint32_t RequestTokenBucketHz() { return mRequestTokenBucketHz; } + uint32_t RequestTokenBucketBurst() {return mRequestTokenBucketBurst; } + + bool PromptTempRedirect() { return mPromptTempRedirect; } + + // TCP Keepalive configuration values. + + // Returns true if TCP keepalive should be enabled for short-lived conns. + bool TCPKeepaliveEnabledForShortLivedConns() { + return mTCPKeepaliveShortLivedEnabled; + } + // Return time (secs) that a connection is consider short lived (for TCP + // keepalive purposes). After this time, the connection is long-lived. + int32_t GetTCPKeepaliveShortLivedTime() { + return mTCPKeepaliveShortLivedTimeS; + } + // Returns time (secs) before first TCP keepalive probes should be sent; + // same time used between successful keepalive probes. + int32_t GetTCPKeepaliveShortLivedIdleTime() { + return mTCPKeepaliveShortLivedIdleTimeS; + } + + // Returns true if TCP keepalive should be enabled for long-lived conns. + bool TCPKeepaliveEnabledForLongLivedConns() { + return mTCPKeepaliveLongLivedEnabled; + } + // Returns time (secs) before first TCP keepalive probes should be sent; + // same time used between successful keepalive probes. + int32_t GetTCPKeepaliveLongLivedIdleTime() { + return mTCPKeepaliveLongLivedIdleTimeS; + } + + // returns the HTTP framing check level preference, as controlled with + // network.http.enforce-framing.http1 and network.http.enforce-framing.soft + FrameCheckLevel GetEnforceH1Framing() { return mEnforceH1Framing; } + + nsHttpAuthCache *AuthCache(bool aPrivate) { + return aPrivate ? &mPrivateAuthCache : &mAuthCache; + } + nsHttpConnectionMgr *ConnMgr() { return mConnMgr; } + + // cache support + uint32_t GenerateUniqueID() { return ++mLastUniqueID; } + uint32_t SessionStartTime() { return mSessionStartTime; } + + // + // Connection management methods: + // + // - the handler only owns idle connections; it does not own active + // connections. + // + // - the handler keeps a count of active connections to enforce the + // steady-state max-connections pref. + // + + // Called to kick-off a new transaction, by default the transaction + // will be put on the pending transaction queue if it cannot be + // initiated at this time. Callable from any thread. + nsresult InitiateTransaction(nsHttpTransaction *trans, int32_t priority) + { + return mConnMgr->AddTransaction(trans, priority); + } + + // Called to change the priority of an existing transaction that has + // already been initiated. + nsresult RescheduleTransaction(nsHttpTransaction *trans, int32_t priority) + { + return mConnMgr->RescheduleTransaction(trans, priority); + } + + // Called to cancel a transaction, which may or may not be assigned to + // a connection. Callable from any thread. + nsresult CancelTransaction(nsHttpTransaction *trans, nsresult reason) + { + return mConnMgr->CancelTransaction(trans, reason); + } + + // Called when a connection is done processing a transaction. Callable + // from any thread. + nsresult ReclaimConnection(nsHttpConnection *conn) + { + return mConnMgr->ReclaimConnection(conn); + } + + nsresult ProcessPendingQ(nsHttpConnectionInfo *cinfo) + { + return mConnMgr->ProcessPendingQ(cinfo); + } + + nsresult ProcessPendingQ() + { + return mConnMgr->ProcessPendingQ(); + } + + nsresult GetSocketThreadTarget(nsIEventTarget **target) + { + return mConnMgr->GetSocketThreadTarget(target); + } + + nsresult SpeculativeConnect(nsHttpConnectionInfo *ci, + nsIInterfaceRequestor *callbacks, + uint32_t caps = 0) + { + TickleWifi(callbacks); + return mConnMgr->SpeculativeConnect(ci, callbacks, caps); + } + + // Alternate Services Maps are main thread only + void UpdateAltServiceMapping(AltSvcMapping *map, + nsProxyInfo *proxyInfo, + nsIInterfaceRequestor *callbacks, + uint32_t caps, + const NeckoOriginAttributes &originAttributes) + { + mConnMgr->UpdateAltServiceMapping(map, proxyInfo, callbacks, caps, + originAttributes); + } + + already_AddRefed<AltSvcMapping> GetAltServiceMapping(const nsACString &scheme, + const nsACString &host, + int32_t port, bool pb) + { + return mConnMgr->GetAltServiceMapping(scheme, host, port, pb); + } + + // + // The HTTP handler caches pointers to specific XPCOM services, and + // provides the following helper routines for accessing those services: + // + nsresult GetStreamConverterService(nsIStreamConverterService **); + nsresult GetIOService(nsIIOService** service); + nsICookieService * GetCookieService(); // not addrefed + nsISiteSecurityService * GetSSService(); + + // callable from socket thread only + uint32_t Get32BitsOfPseudoRandom(); + + // Called by the channel synchronously during asyncOpen + void OnOpeningRequest(nsIHttpChannel *chan) + { + NotifyObservers(chan, NS_HTTP_ON_OPENING_REQUEST_TOPIC); + } + + // Called by the channel before writing a request + void OnModifyRequest(nsIHttpChannel *chan) + { + NotifyObservers(chan, NS_HTTP_ON_MODIFY_REQUEST_TOPIC); + } + + // Called by the channel and cached in the loadGroup + void OnUserAgentRequest(nsIHttpChannel *chan) + { + NotifyObservers(chan, NS_HTTP_ON_USERAGENT_REQUEST_TOPIC); + } + + // Called by the channel once headers are available + void OnExamineResponse(nsIHttpChannel *chan) + { + NotifyObservers(chan, NS_HTTP_ON_EXAMINE_RESPONSE_TOPIC); + } + + // Called by the channel once headers have been merged with cached headers + void OnExamineMergedResponse(nsIHttpChannel *chan) + { + NotifyObservers(chan, NS_HTTP_ON_EXAMINE_MERGED_RESPONSE_TOPIC); + } + + // Called by channels before a redirect happens. This notifies both the + // channel's and the global redirect observers. + nsresult AsyncOnChannelRedirect(nsIChannel* oldChan, nsIChannel* newChan, + uint32_t flags); + + // Called by the channel when the response is read from the cache without + // communicating with the server. + void OnExamineCachedResponse(nsIHttpChannel *chan) + { + NotifyObservers(chan, NS_HTTP_ON_EXAMINE_CACHED_RESPONSE_TOPIC); + } + + // Generates the host:port string for use in the Host: header as well as the + // CONNECT line for proxies. This handles IPv6 literals correctly. + static nsresult GenerateHostPort(const nsCString& host, int32_t port, + nsACString& hostLine); + + bool GetPipelineAggressive() { return mPipelineAggressive; } + void GetMaxPipelineObjectSize(int64_t *outVal) + { + *outVal = mMaxPipelineObjectSize; + } + + bool GetPipelineEnabled() + { + return mCapabilities & NS_HTTP_ALLOW_PIPELINING; + } + + bool GetPipelineRescheduleOnTimeout() + { + return mPipelineRescheduleOnTimeout; + } + + PRIntervalTime GetPipelineRescheduleTimeout() + { + return mPipelineRescheduleTimeout; + } + + PRIntervalTime GetPipelineTimeout() { return mPipelineReadTimeout; } + + SpdyInformation *SpdyInfo() { return &mSpdyInfo; } + bool IsH2MandatorySuiteEnabled() { return mH2MandatorySuiteEnabled; } + + // Returns true if content-signature test pref is set such that they are + // NOT enforced on remote newtabs. + bool NewTabContentSignaturesDisabled() + { + return mNewTabContentSignaturesDisabled; + } + + // returns true in between Init and Shutdown states + bool Active() { return mHandlerActive; } + + // When the disk cache is responding slowly its use is suppressed + // for 1 minute for most requests. Callable from main thread only. + TimeStamp GetCacheSkippedUntil() { return mCacheSkippedUntil; } + void SetCacheSkippedUntil(TimeStamp arg) { mCacheSkippedUntil = arg; } + void ClearCacheSkippedUntil() { mCacheSkippedUntil = TimeStamp(); } + + nsIRequestContextService *GetRequestContextService() + { + return mRequestContextService.get(); + } + + void ShutdownConnectionManager(); + + bool KeepEmptyResponseHeadersAsEmtpyString() const + { + return mKeepEmptyResponseHeadersAsEmtpyString; + } + + uint32_t DefaultHpackBuffer() const + { + return mDefaultHpackBuffer; + } + + uint32_t MaxHttpResponseHeaderSize() const + { + return mMaxHttpResponseHeaderSize; + } + +private: + virtual ~nsHttpHandler(); + + // + // Useragent/prefs helper methods + // + void BuildUserAgent(); + void InitUserAgentComponents(); + void PrefsChanged(nsIPrefBranch *prefs, const char *pref); + + nsresult SetAccept(const char *); + nsresult SetAcceptLanguages(const char *); + nsresult SetAcceptEncodings(const char *, bool mIsSecure); + + nsresult InitConnectionMgr(); + + void NotifyObservers(nsIHttpChannel *chan, const char *event); + + static void TimerCallback(nsITimer * aTimer, void * aClosure); +private: + + // cached services + nsMainThreadPtrHandle<nsIIOService> mIOService; + nsMainThreadPtrHandle<nsIStreamConverterService> mStreamConvSvc; + nsMainThreadPtrHandle<nsICookieService> mCookieService; + nsMainThreadPtrHandle<nsISiteSecurityService> mSSService; + + // the authentication credentials cache + nsHttpAuthCache mAuthCache; + nsHttpAuthCache mPrivateAuthCache; + + // the connection manager + RefPtr<nsHttpConnectionMgr> mConnMgr; + + // + // prefs + // + + uint8_t mHttpVersion; + uint8_t mProxyHttpVersion; + uint32_t mCapabilities; + uint8_t mReferrerLevel; + uint8_t mSpoofReferrerSource; + uint8_t mReferrerTrimmingPolicy; + uint8_t mReferrerXOriginTrimmingPolicy; + uint8_t mReferrerXOriginPolicy; + + bool mFastFallbackToIPv4; + bool mProxyPipelining; + PRIntervalTime mIdleTimeout; + PRIntervalTime mSpdyTimeout; + PRIntervalTime mResponseTimeout; + bool mResponseTimeoutEnabled; + uint32_t mNetworkChangedTimeout; // milliseconds + uint16_t mMaxRequestAttempts; + uint16_t mMaxRequestDelay; + uint16_t mIdleSynTimeout; + + bool mH2MandatorySuiteEnabled; + bool mPipeliningEnabled; + uint16_t mMaxConnections; + uint8_t mMaxPersistentConnectionsPerServer; + uint8_t mMaxPersistentConnectionsPerProxy; + uint16_t mMaxPipelinedRequests; + uint16_t mMaxOptimisticPipelinedRequests; + bool mPipelineAggressive; + int64_t mMaxPipelineObjectSize; + bool mPipelineRescheduleOnTimeout; + PRIntervalTime mPipelineRescheduleTimeout; + PRIntervalTime mPipelineReadTimeout; + nsCOMPtr<nsITimer> mPipelineTestTimer; + + uint8_t mRedirectionLimit; + + // we'll warn the user if we load an URL containing a userpass field + // unless its length is less than this threshold. this warning is + // intended to protect the user against spoofing attempts that use + // the userpass field of the URL to obscure the actual origin server. + uint8_t mPhishyUserPassLength; + + uint8_t mQoSBits; + + bool mPipeliningOverSSL; + bool mEnforceAssocReq; + + nsCString mAccept; + nsCString mAcceptLanguages; + nsCString mHttpAcceptEncodings; + nsCString mHttpsAcceptEncodings; + + nsXPIDLCString mDefaultSocketType; + + // cache support + uint32_t mLastUniqueID; + uint32_t mSessionStartTime; + + // useragent components + nsCString mLegacyAppName; + nsCString mLegacyAppVersion; + nsCString mPlatform; + nsCString mOscpu; + nsCString mMisc; + nsCString mProduct; + nsXPIDLCString mProductSub; + nsXPIDLCString mAppName; + nsXPIDLCString mAppVersion; + nsCString mCompatFirefox; + bool mCompatFirefoxEnabled; + nsXPIDLCString mCompatDevice; + nsCString mDeviceModelId; + + nsCString mUserAgent; + nsXPIDLCString mUserAgentOverride; + bool mUserAgentIsDirty; // true if mUserAgent should be rebuilt + + + bool mPromptTempRedirect; + + // Persistent HTTPS caching flag + bool mEnablePersistentHttpsCaching; + + // For broadcasting tracking preference + bool mDoNotTrackEnabled; + + // for broadcasting safe hint; + bool mSafeHintEnabled; + bool mParentalControlEnabled; + + // true in between init and shutdown states + Atomic<bool, Relaxed> mHandlerActive; + + // Whether telemetry is reported or not + uint32_t mTelemetryEnabled : 1; + + // The value of network.allow-experiments + uint32_t mAllowExperiments : 1; + + // The value of 'hidden' network.http.debug-observations : 1; + uint32_t mDebugObservations : 1; + + uint32_t mEnableSpdy : 1; + uint32_t mHttp2Enabled : 1; + uint32_t mUseH2Deps : 1; + uint32_t mEnforceHttp2TlsProfile : 1; + uint32_t mCoalesceSpdy : 1; + uint32_t mSpdyPersistentSettings : 1; + uint32_t mAllowPush : 1; + uint32_t mEnableAltSvc : 1; + uint32_t mEnableAltSvcOE : 1; + + // Try to use SPDY features instead of HTTP/1.1 over SSL + SpdyInformation mSpdyInfo; + + uint32_t mSpdySendingChunkSize; + uint32_t mSpdySendBufferSize; + uint32_t mSpdyPushAllowance; + uint32_t mSpdyPullAllowance; + uint32_t mDefaultSpdyConcurrent; + PRIntervalTime mSpdyPingThreshold; + PRIntervalTime mSpdyPingTimeout; + + // The maximum amount of time to wait for socket transport to be + // established. In milliseconds. + uint32_t mConnectTimeout; + + // The maximum number of current global half open sockets allowable + // when starting a new speculative connection. + uint32_t mParallelSpeculativeConnectLimit; + + // For Rate Pacing of HTTP/1 requests through a netwerk/base/EventTokenBucket + // Active requests <= *MinParallelism are not subject to the rate pacing + bool mRequestTokenBucketEnabled; + uint16_t mRequestTokenBucketMinParallelism; + uint32_t mRequestTokenBucketHz; // EventTokenBucket HZ + uint32_t mRequestTokenBucketBurst; // EventTokenBucket Burst + + // Whether or not to block requests for non head js/css items (e.g. media) + // while those elements load. + bool mCriticalRequestPrioritization; + + // When the disk cache is responding slowly its use is suppressed + // for 1 minute for most requests. + TimeStamp mCacheSkippedUntil; + + // TCP Keepalive configuration values. + + // True if TCP keepalive is enabled for short-lived conns. + bool mTCPKeepaliveShortLivedEnabled; + // Time (secs) indicating how long a conn is considered short-lived. + int32_t mTCPKeepaliveShortLivedTimeS; + // Time (secs) before first keepalive probe; between successful probes. + int32_t mTCPKeepaliveShortLivedIdleTimeS; + + // True if TCP keepalive is enabled for long-lived conns. + bool mTCPKeepaliveLongLivedEnabled; + // Time (secs) before first keepalive probe; between successful probes. + int32_t mTCPKeepaliveLongLivedIdleTimeS; + + // if true, generate NS_ERROR_PARTIAL_TRANSFER for h1 responses with + // incorrect content lengths or malformed chunked encodings + FrameCheckLevel mEnforceH1Framing; + + nsCOMPtr<nsIRequestContextService> mRequestContextService; + + // True if remote newtab content-signature disabled because of the channel. + bool mNewTabContentSignaturesDisabled; + + // If it is set to false, headers with empty value will not appear in the + // header array - behavior as it used to be. If it is true: empty headers + // coming from the network will exits in header array as empty string. + // Call SetHeader with an empty value will still delete the header. + // (Bug 6699259) + bool mKeepEmptyResponseHeadersAsEmtpyString; + + // The default size (in bytes) of the HPACK decompressor table. + uint32_t mDefaultHpackBuffer; + + // The max size (in bytes) for received Http response header. + uint32_t mMaxHttpResponseHeaderSize; + +private: + // For Rate Pacing Certain Network Events. Only assign this pointer on + // socket thread. + void MakeNewRequestTokenBucket(); + RefPtr<EventTokenBucket> mRequestTokenBucket; + +public: + // Socket thread only + nsresult SubmitPacedRequest(ATokenBucketEvent *event, + nsICancelable **cancel) + { + MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread); + if (!mRequestTokenBucket) { + return NS_ERROR_NOT_AVAILABLE; + } + return mRequestTokenBucket->SubmitEvent(event, cancel); + } + + // Socket thread only + void SetRequestTokenBucket(EventTokenBucket *aTokenBucket) + { + MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread); + mRequestTokenBucket = aTokenBucket; + } + + void StopRequestTokenBucket() + { + MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread); + if (mRequestTokenBucket) { + mRequestTokenBucket->Stop(); + mRequestTokenBucket = nullptr; + } + } + +private: + RefPtr<Tickler> mWifiTickler; + void TickleWifi(nsIInterfaceRequestor *cb); + +private: + nsresult SpeculativeConnectInternal(nsIURI *aURI, + nsIPrincipal *aPrincipal, + nsIInterfaceRequestor *aCallbacks, + bool anonymous); + + // UUID generator for channelIds + nsCOMPtr<nsIUUIDGenerator> mUUIDGen; + +public: + nsresult NewChannelId(nsID *channelId); +}; + +extern nsHttpHandler *gHttpHandler; + +//----------------------------------------------------------------------------- +// nsHttpsHandler - thin wrapper to distinguish the HTTP handler from the +// HTTPS handler (even though they share the same impl). +//----------------------------------------------------------------------------- + +class nsHttpsHandler : public nsIHttpProtocolHandler + , public nsSupportsWeakReference + , public nsISpeculativeConnect +{ + virtual ~nsHttpsHandler() { } +public: + // we basically just want to override GetScheme and GetDefaultPort... + // all other methods should be forwarded to the nsHttpHandler instance. + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIPROTOCOLHANDLER + NS_FORWARD_NSIPROXIEDPROTOCOLHANDLER (gHttpHandler->) + NS_FORWARD_NSIHTTPPROTOCOLHANDLER (gHttpHandler->) + NS_FORWARD_NSISPECULATIVECONNECT (gHttpHandler->) + + nsHttpsHandler() { } + + nsresult Init(); +}; + +} // namespace net +} // namespace mozilla + +#endif // nsHttpHandler_h__ |