The Tor Browser: comparison netwerk/protocol/http/nsHttpChannel.cpp

--1:000000000000
+:876c8c95adda
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim:set expandtab ts=4 sw=4 sts=4 cin: */
+/* 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/. */
+// HttpLog.h should generally be included first
+#include "HttpLog.h"
+#include "nsHttp.h"
+#include "nsHttpChannel.h"
+#include "nsHttpHandler.h"
+#include "nsIApplicationCacheService.h"
+#include "nsIApplicationCacheContainer.h"
+#include "nsICacheStorageService.h"
+#include "nsICacheStorage.h"
+#include "nsICacheEntry.h"
+#include "nsICryptoHash.h"
+#include "nsIStringBundle.h"
+#include "nsIStreamListenerTee.h"
+#include "nsISeekableStream.h"
+#include "nsILoadGroupChild.h"
+#include "nsIProtocolProxyService2.h"
+#include "nsMimeTypes.h"
+#include "nsNetUtil.h"
+#include "prprf.h"
+#include "prnetdb.h"
+#include "nsEscape.h"
+#include "nsStreamUtils.h"
+#include "nsIOService.h"
+#include "nsDNSPrefetch.h"
+#include "nsChannelClassifier.h"
+#include "nsIRedirectResultListener.h"
+#include "mozilla/TimeStamp.h"
+#include "nsError.h"
+#include "nsPrintfCString.h"
+#include "nsAlgorithm.h"
+#include "GeckoProfiler.h"
+#include "nsIConsoleService.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/VisualEventTracer.h"
+#include "nsISSLSocketControl.h"
+#include "sslt.h"
+#include "nsContentUtils.h"
+#include "nsIPermissionManager.h"
+#include "nsIPrincipal.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsISSLStatus.h"
+#include "nsISSLStatusProvider.h"
+#include "LoadContextInfo.h"
+#include "netCore.h"
+#include "nsHttpTransaction.h"
+#include "nsICacheEntryDescriptor.h"
+#include "nsICancelable.h"
+#include "nsIHttpChannelAuthProvider.h"
+#include "nsIHttpEventSink.h"
+#include "nsIPrompt.h"
+#include "nsInputStreamPump.h"
+#include "nsURLHelper.h"
+#include "nsISocketTransport.h"
+#include "nsICacheSession.h"
+#include "nsIStreamConverterService.h"
+#include "nsISiteSecurityService.h"
+#include "nsCRT.h"
+#include "nsPIDOMWindow.h"
+#include "nsPerformance.h"
+#include "CacheObserver.h"
+#include "mozilla/Telemetry.h"
+#include "mozIThirdPartyUtil.h"
+namespace mozilla { namespace net {
+namespace {
+// True if the local cache should be bypassed when processing a request.
+#define BYPASS_LOCAL_CACHE(loadFlags) \
+(loadFlags & (nsIRequest::LOAD_BYPASS_CACHE | \
+nsICachingChannel::LOAD_BYPASS_LOCAL_CACHE))
+#define CACHE_FILE_GONE(result) \
+((result) == NS_ERROR_FILE_NOT_FOUND || \
+(result) == NS_ERROR_FILE_CORRUPTED)
+static NS_DEFINE_CID(kStreamListenerTeeCID, NS_STREAMLISTENERTEE_CID);
+static NS_DEFINE_CID(kStreamTransportServiceCID,
+NS_STREAMTRANSPORTSERVICE_CID);
+enum CacheDisposition {
+kCacheHit = 1,
+kCacheHitViaReval = 2,
+kCacheMissedViaReval = 3,
+kCacheMissed = 4
+};
+void
+AccumulateCacheHitTelemetry(CacheDisposition hitOrMiss)
+{
+if (!CacheObserver::UseNewCache()) {
+Telemetry::Accumulate(Telemetry::HTTP_CACHE_DISPOSITION_2, hitOrMiss);
+}
+else {
+Telemetry::Accumulate(Telemetry::HTTP_CACHE_DISPOSITION_2_V2, hitOrMiss);
+int32_t experiment = CacheObserver::HalfLifeExperiment();
+if (experiment > 0 && hitOrMiss == kCacheMissed) {
+Telemetry::Accumulate(Telemetry::HTTP_CACHE_MISS_HALFLIFE_EXPERIMENT,
+experiment - 1);
+}
+}
+}
+// Computes and returns a SHA1 hash of the input buffer. The input buffer
+// must be a null-terminated string.
+nsresult
+Hash(const char *buf, nsACString &hash)
+{
+nsresult rv;
+nsCOMPtr<nsICryptoHash> hasher
+= do_CreateInstance(NS_CRYPTO_HASH_CONTRACTID, &rv);
+NS_ENSURE_SUCCESS(rv, rv);
+rv = hasher->Init(nsICryptoHash::SHA1);
+NS_ENSURE_SUCCESS(rv, rv);
+rv = hasher->Update(reinterpret_cast<unsigned const char*>(buf),
+strlen(buf));
+NS_ENSURE_SUCCESS(rv, rv);
+rv = hasher->Finish(true, hash);
+NS_ENSURE_SUCCESS(rv, rv);
+return NS_OK;
+}
+bool IsRedirectStatus(uint32_t status)
+{
+// 305 disabled as a security measure (see bug 187996).
+return status == 300 || status == 301 || status == 302 || status == 303 ||
+status == 307 || status == 308;
+}
+// We only treat 3xx responses as redirects if they have a Location header and
+// the status code is in a whitelist.
+bool
+WillRedirect(const nsHttpResponseHead * response)
+{
+return IsRedirectStatus(response->Status()) &&
+response->PeekHeader(nsHttp::Location);
+}
+} // unnamed namespace
+class AutoRedirectVetoNotifier
+{
+public:
+AutoRedirectVetoNotifier(nsHttpChannel* channel) : mChannel(channel)
+{
+if (mChannel->mHasAutoRedirectVetoNotifier) {
+MOZ_CRASH("Nested AutoRedirectVetoNotifier on the stack");
+mChannel = nullptr;
+return;
+}
+mChannel->mHasAutoRedirectVetoNotifier = true;
+}
+~AutoRedirectVetoNotifier() {ReportRedirectResult(false);}
+void RedirectSucceeded() {ReportRedirectResult(true);}
+private:
+nsHttpChannel* mChannel;
+void ReportRedirectResult(bool succeeded);
+};
+void
+AutoRedirectVetoNotifier::ReportRedirectResult(bool succeeded)
+{
+if (!mChannel)
+return;
+mChannel->mRedirectChannel = nullptr;
+nsCOMPtr<nsIRedirectResultListener> vetoHook;
+NS_QueryNotificationCallbacks(mChannel,
+NS_GET_IID(nsIRedirectResultListener),
+getter_AddRefs(vetoHook));
+nsHttpChannel* channel = mChannel;
+mChannel = nullptr;
+if (vetoHook)
+vetoHook->OnRedirectResult(succeeded);
+// Drop after the notification
+channel->mHasAutoRedirectVetoNotifier = false;
+MOZ_EVENT_TRACER_DONE(channel, "net::http::redirect-callbacks");
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel <public>
+//-----------------------------------------------------------------------------
+nsHttpChannel::nsHttpChannel()
+: HttpAsyncAborter<nsHttpChannel>(MOZ_THIS_IN_INITIALIZER_LIST())
+, mLogicalOffset(0)
+, mPostID(0)
+, mRequestTime(0)
+, mOfflineCacheLastModifiedTime(0)
+, mCachedContentIsValid(false)
+, mCachedContentIsPartial(false)
+, mTransactionReplaced(false)
+, mAuthRetryPending(false)
+, mProxyAuthPending(false)
+, mResuming(false)
+, mInitedCacheEntry(false)
+, mFallbackChannel(false)
+, mCustomConditionalRequest(false)
+, mFallingBack(false)
+, mWaitingForRedirectCallback(false)
+, mRequestTimeInitialized(false)
+, mCacheEntryIsReadOnly(false)
+, mCacheEntryIsWriteOnly(false)
+, mCacheEntriesToWaitFor(0)
+, mHasQueryString(0)
+, mConcurentCacheAccess(0)
+, mIsPartialRequest(0)
+, mHasAutoRedirectVetoNotifier(0)
+, mDidReval(false)
+, mForcePending(false)
+{
+LOG(("Creating nsHttpChannel [this=%p]\n", this));
+mChannelCreationTime = PR_Now();
+mChannelCreationTimestamp = TimeStamp::Now();
+}
+nsHttpChannel::~nsHttpChannel()
+{
+LOG(("Destroying nsHttpChannel [this=%p]\n", this));
+if (mAuthProvider)
+mAuthProvider->Disconnect(NS_ERROR_ABORT);
+}
+nsresult
+nsHttpChannel::Init(nsIURI *uri,
+uint32_t caps,
+nsProxyInfo *proxyInfo,
+uint32_t proxyResolveFlags,
+nsIURI *proxyURI)
+{
+#ifdef MOZ_VISUAL_EVENT_TRACER
+nsAutoCString url;
+uri->GetAsciiSpec(url);
+MOZ_EVENT_TRACER_NAME_OBJECT(this, url.get());
+#endif
+nsresult rv = HttpBaseChannel::Init(uri, caps, proxyInfo,
+proxyResolveFlags, proxyURI);
+if (NS_FAILED(rv))
+return rv;
+LOG(("nsHttpChannel::Init [this=%p]\n", this));
+return rv;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel <private>
+//-----------------------------------------------------------------------------
+nsresult
+nsHttpChannel::Connect()
+{
+nsresult rv;
+LOG(("nsHttpChannel::Connect [this=%p]\n", this));
+// Even if we're in private browsing mode, we still enforce existing STS
+// data (it is read-only).
+// if the connection is not using SSL and either the exact host matches or
+// a superdomain wants to force HTTPS, do it.
+bool usingSSL = false;
+rv = mURI->SchemeIs("https", &usingSSL);
+NS_ENSURE_SUCCESS(rv,rv);
+if (!usingSSL) {
+// enforce Strict-Transport-Security
+nsISiteSecurityService* sss = gHttpHandler->GetSSService();
+NS_ENSURE_TRUE(sss, NS_ERROR_OUT_OF_MEMORY);
+bool isStsHost = false;
+uint32_t flags = mPrivateBrowsing ? nsISocketProvider::NO_PERMANENT_STORAGE : 0;
+rv = sss->IsSecureURI(nsISiteSecurityService::HEADER_HSTS, mURI, flags,
+&isStsHost);
+// if the SSS check fails, it's likely because this load is on a
+// malformed URI or something else in the setup is wrong, so any error
+// should be reported.
+NS_ENSURE_SUCCESS(rv, rv);
+if (isStsHost) {
+LOG(("nsHttpChannel::Connect() STS permissions found\n"));
+return AsyncCall(&nsHttpChannel::HandleAsyncRedirectChannelToHttps);
+}
+}
+// ensure that we are using a valid hostname
+if (!net_IsValidHostName(nsDependentCString(mConnectionInfo->Host())))
+return NS_ERROR_UNKNOWN_HOST;
+// Finalize ConnectionInfo flags before SpeculativeConnect
+mConnectionInfo->SetAnonymous((mLoadFlags & LOAD_ANONYMOUS) != 0);
+mConnectionInfo->SetPrivate(mPrivateBrowsing);
+// Consider opening a TCP connection right away
+RetrieveSSLOptions();
+SpeculativeConnect();
+// Don't allow resuming when cache must be used
+if (mResuming && (mLoadFlags & LOAD_ONLY_FROM_CACHE)) {
+LOG(("Resuming from cache is not supported yet"));
+return NS_ERROR_DOCUMENT_NOT_CACHED;
+}
+if (!gHttpHandler->UseCache()) {
+return ContinueConnect();
+}
+// open a cache entry for this channel...
+rv = OpenCacheEntry(usingSSL);
+// do not continue if asyncOpenCacheEntry is in progress
+if (mCacheEntriesToWaitFor) {
+MOZ_ASSERT(NS_SUCCEEDED(rv), "Unexpected state");
+return NS_OK;
+}
+if (NS_FAILED(rv)) {
+LOG(("OpenCacheEntry failed [rv=%x]\n", rv));
+// if this channel is only allowed to pull from the cache, then
+// we must fail if we were unable to open a cache entry.
+if (mLoadFlags & LOAD_ONLY_FROM_CACHE) {
+// If we have a fallback URI (and we're not already
+// falling back), process the fallback asynchronously.
+if (!mFallbackChannel && !mFallbackKey.IsEmpty()) {
+return AsyncCall(&nsHttpChannel::HandleAsyncFallback);
+}
+return NS_ERROR_DOCUMENT_NOT_CACHED;
+}
+// otherwise, let's just proceed without using the cache.
+}
+return ContinueConnect();
+}
+nsresult
+nsHttpChannel::ContinueConnect()
+{
+// we may or may not have a cache entry at this point
+if (mCacheEntry) {
+// read straight from the cache if possible...
+if (mCachedContentIsValid) {
+nsRunnableMethod<nsHttpChannel> *event = nullptr;
+if (!mCachedContentIsPartial) {
+AsyncCall(&nsHttpChannel::AsyncOnExamineCachedResponse, &event);
+}
+nsresult rv = ReadFromCache(true);
+if (NS_FAILED(rv) && event) {
+event->Revoke();
+}
+AccumulateCacheHitTelemetry(kCacheHit);
+return rv;
+}
+else if (mLoadFlags & LOAD_ONLY_FROM_CACHE) {
+// the cache contains the requested resource, but it must be
+// validated before we can reuse it.  since we are not allowed
+// to hit the net, there's nothing more to do.  the document
+// is effectively not in the cache.
+LOG(("  !mCachedContentIsValid && mLoadFlags & LOAD_ONLY_FROM_CACHE"));
+return NS_ERROR_DOCUMENT_NOT_CACHED;
+}
+}
+else if (mLoadFlags & LOAD_ONLY_FROM_CACHE) {
+// If we have a fallback URI (and we're not already
+// falling back), process the fallback asynchronously.
+if (!mFallbackChannel && !mFallbackKey.IsEmpty()) {
+return AsyncCall(&nsHttpChannel::HandleAsyncFallback);
+}
+LOG(("  !mCachedEntry && mLoadFlags & LOAD_ONLY_FROM_CACHE"));
+return NS_ERROR_DOCUMENT_NOT_CACHED;
+}
+if (mLoadFlags & LOAD_NO_NETWORK_IO) {
+LOG(("  mLoadFlags & LOAD_NO_NETWORK_IO"));
+return NS_ERROR_DOCUMENT_NOT_CACHED;
+}
+// hit the net...
+nsresult rv = SetupTransaction();
+if (NS_FAILED(rv)) return rv;
+rv = gHttpHandler->InitiateTransaction(mTransaction, mPriority);
+if (NS_FAILED(rv)) return rv;
+rv = mTransactionPump->AsyncRead(this, nullptr);
+if (NS_FAILED(rv)) return rv;
+uint32_t suspendCount = mSuspendCount;
+while (suspendCount--)
+mTransactionPump->Suspend();
+return NS_OK;
+}
+void
+nsHttpChannel::SpeculativeConnect()
+{
+// Before we take the latency hit of dealing with the cache, try and
+// get the TCP (and SSL) handshakes going so they can overlap.
+// don't speculate on uses of the offline application cache,
+// if we are offline, when doing http upgrade (i.e. websockets bootstrap),
+// or if we can't do keep-alive (because then we couldn't reuse
+// the speculative connection anyhow).
+if (mApplicationCache || gIOService->IsOffline() ||
+mUpgradeProtocolCallback || !(mCaps & NS_HTTP_ALLOW_KEEPALIVE))
+return;
+// LOAD_ONLY_FROM_CACHE and LOAD_NO_NETWORK_IO must not hit network.
+// LOAD_FROM_CACHE and LOAD_CHECK_OFFLINE_CACHE are unlikely to hit network,
+// so skip preconnects for them.
+if (mLoadFlags & (LOAD_ONLY_FROM_CACHE | LOAD_FROM_CACHE |
+LOAD_NO_NETWORK_IO | LOAD_CHECK_OFFLINE_CACHE))
+return;
+nsCOMPtr<nsIInterfaceRequestor> callbacks;
+NS_NewNotificationCallbacksAggregation(mCallbacks, mLoadGroup,
+getter_AddRefs(callbacks));
+if (!callbacks)
+return;
+gHttpHandler->SpeculativeConnect(
+mConnectionInfo, callbacks,
+mCaps & (NS_HTTP_ALLOW_RSA_FALSESTART | NS_HTTP_DISALLOW_SPDY));
+}
+void
+nsHttpChannel::DoNotifyListenerCleanup()
+{
+// We don't need this info anymore
+CleanRedirectCacheChainIfNecessary();
+}
+void
+nsHttpChannel::HandleAsyncRedirect()
+{
+NS_PRECONDITION(!mCallOnResume, "How did that happen?");
+if (mSuspendCount) {
+LOG(("Waiting until resume to do async redirect [this=%p]\n", this));
+mCallOnResume = &nsHttpChannel::HandleAsyncRedirect;
+return;
+}
+nsresult rv = NS_OK;
+LOG(("nsHttpChannel::HandleAsyncRedirect [this=%p]\n", this));
+// since this event is handled asynchronously, it is possible that this
+// channel could have been canceled, in which case there would be no point
+// in processing the redirect.
+if (NS_SUCCEEDED(mStatus)) {
+PushRedirectAsyncFunc(&nsHttpChannel::ContinueHandleAsyncRedirect);
+rv = AsyncProcessRedirection(mResponseHead->Status());
+if (NS_FAILED(rv)) {
+PopRedirectAsyncFunc(&nsHttpChannel::ContinueHandleAsyncRedirect);
+// TODO: if !DoNotRender3xxBody(), render redirect body instead.
+// But first we need to cache 3xx bodies (bug 748510)
+ContinueHandleAsyncRedirect(rv);
+}
+}
+else {
+ContinueHandleAsyncRedirect(NS_OK);
+}
+}
+nsresult
+nsHttpChannel::ContinueHandleAsyncRedirect(nsresult rv)
+{
+if (NS_FAILED(rv)) {
+// If AsyncProcessRedirection fails, then we have to send out the
+// OnStart/OnStop notifications.
+LOG(("ContinueHandleAsyncRedirect got failure result [rv=%x]\n", rv));
+mStatus = rv;
+DoNotifyListener();
+}
+// close the cache entry.  Blow it away if we couldn't process the redirect
+// for some reason (the cache entry might be corrupt).
+if (mCacheEntry) {
+if (NS_FAILED(rv))
+mCacheEntry->AsyncDoom(nullptr);
+}
+CloseCacheEntry(false);
+mIsPending = false;
+if (mLoadGroup)
+mLoadGroup->RemoveRequest(this, nullptr, mStatus);
+return NS_OK;
+}
+void
+nsHttpChannel::HandleAsyncNotModified()
+{
+NS_PRECONDITION(!mCallOnResume, "How did that happen?");
+if (mSuspendCount) {
+LOG(("Waiting until resume to do async not-modified [this=%p]\n",
+this));
+mCallOnResume = &nsHttpChannel::HandleAsyncNotModified;
+return;
+}
+LOG(("nsHttpChannel::HandleAsyncNotModified [this=%p]\n", this));
+DoNotifyListener();
+CloseCacheEntry(true);
+mIsPending = false;
+if (mLoadGroup)
+mLoadGroup->RemoveRequest(this, nullptr, mStatus);
+}
+void
+nsHttpChannel::HandleAsyncFallback()
+{
+NS_PRECONDITION(!mCallOnResume, "How did that happen?");
+if (mSuspendCount) {
+LOG(("Waiting until resume to do async fallback [this=%p]\n", this));
+mCallOnResume = &nsHttpChannel::HandleAsyncFallback;
+return;
+}
+nsresult rv = NS_OK;
+LOG(("nsHttpChannel::HandleAsyncFallback [this=%p]\n", this));
+// since this event is handled asynchronously, it is possible that this
+// channel could have been canceled, in which case there would be no point
+// in processing the fallback.
+if (!mCanceled) {
+PushRedirectAsyncFunc(&nsHttpChannel::ContinueHandleAsyncFallback);
+bool waitingForRedirectCallback;
+rv = ProcessFallback(&waitingForRedirectCallback);
+if (waitingForRedirectCallback)
+return;
+PopRedirectAsyncFunc(&nsHttpChannel::ContinueHandleAsyncFallback);
+}
+ContinueHandleAsyncFallback(rv);
+}
+nsresult
+nsHttpChannel::ContinueHandleAsyncFallback(nsresult rv)
+{
+if (!mCanceled && (NS_FAILED(rv) || !mFallingBack)) {
+// If ProcessFallback fails, then we have to send out the
+// OnStart/OnStop notifications.
+LOG(("ProcessFallback failed [rv=%x, %d]\n", rv, mFallingBack));
+mStatus = NS_FAILED(rv) ? rv : NS_ERROR_DOCUMENT_NOT_CACHED;
+DoNotifyListener();
+}
+mIsPending = false;
+if (mLoadGroup)
+mLoadGroup->RemoveRequest(this, nullptr, mStatus);
+return rv;
+}
+void
+nsHttpChannel::SetupTransactionLoadGroupInfo()
+{
+// Find the loadgroup at the end of the chain in order
+// to make sure all channels derived from the load group
+// use the same connection scope.
+nsCOMPtr<nsILoadGroupChild> childLoadGroup = do_QueryInterface(mLoadGroup);
+if (!childLoadGroup)
+return;
+nsCOMPtr<nsILoadGroup> rootLoadGroup;
+childLoadGroup->GetRootLoadGroup(getter_AddRefs(rootLoadGroup));
+if (!rootLoadGroup)
+return;
+// Set the load group connection scope on the transaction
+nsCOMPtr<nsILoadGroupConnectionInfo> ci;
+rootLoadGroup->GetConnectionInfo(getter_AddRefs(ci));
+if (ci)
+mTransaction->SetLoadGroupConnectionInfo(ci);
+}
+void
+nsHttpChannel::RetrieveSSLOptions()
+{
+if (!IsHTTPS() || mPrivateBrowsing)
+return;
+nsIPrincipal *principal = GetPrincipal();
+if (!principal)
+return;
+nsCOMPtr<nsIPermissionManager> permMgr =
+do_GetService(NS_PERMISSIONMANAGER_CONTRACTID);
+if (!permMgr)
+return;
+uint32_t perm;
+nsresult rv = permMgr->TestPermissionFromPrincipal(principal,
+"falsestart-rsa", &perm);
+if (NS_SUCCEEDED(rv) && perm == nsIPermissionManager::ALLOW_ACTION) {
+LOG(("nsHttpChannel::RetrieveSSLOptions [this=%p] "
+"falsestart-rsa permission found\n", this));
+mCaps |= NS_HTTP_ALLOW_RSA_FALSESTART;
+}
+}
+static bool
+SafeForPipelining(nsHttpRequestHead::ParsedMethodType method,
+const nsCString &methodString)
+{
+if (method == nsHttpRequestHead::kMethod_Get ||
+method == nsHttpRequestHead::kMethod_Head ||
+method == nsHttpRequestHead::kMethod_Options) {
+return true;
+}
+if (method != nsHttpRequestHead::kMethod_Custom) {
+return false;
+}
+return (!strcmp(methodString.get(), "PROPFIND") ||
+!strcmp(methodString.get(), "PROPPATCH"));
+}
+nsresult
+nsHttpChannel::SetupTransaction()
+{
+LOG(("nsHttpChannel::SetupTransaction [this=%p]\n", this));
+NS_ENSURE_TRUE(!mTransaction, NS_ERROR_ALREADY_INITIALIZED);
+nsresult rv;
+if (mCaps & NS_HTTP_ALLOW_PIPELINING) {
+//
+// disable pipelining if:
+//   (1) pipelining has been disabled by config
+//   (2) pipelining has been disabled by connection mgr info
+//   (3) request corresponds to a top-level document load (link click)
+//   (4) request method is non-idempotent
+//   (5) request is marked slow (e.g XHR)
+//
+if (!mAllowPipelining ||
+(mLoadFlags & (LOAD_INITIAL_DOCUMENT_URI | INHIBIT_PIPELINE)) ||
+!SafeForPipelining(mRequestHead.ParsedMethod(), mRequestHead.Method())) {
+LOG(("  pipelining disallowed\n"));
+mCaps &= ~NS_HTTP_ALLOW_PIPELINING;
+}
+}
+if (!mAllowSpdy)
+mCaps |= NS_HTTP_DISALLOW_SPDY;
+// Use the URI path if not proxying (transparent proxying such as proxy
+// CONNECT does not count here). Also figure out what HTTP version to use.
+nsAutoCString buf, path;
+nsCString* requestURI;
+if (mConnectionInfo->UsingConnect() ||
+!mConnectionInfo->UsingHttpProxy()) {
+rv = mURI->GetPath(path);
+if (NS_FAILED(rv)) return rv;
+// path may contain UTF-8 characters, so ensure that they're escaped.
+if (NS_EscapeURL(path.get(), path.Length(), esc_OnlyNonASCII, buf))
+requestURI = &buf;
+else
+requestURI = &path;
+mRequestHead.SetVersion(gHttpHandler->HttpVersion());
+}
+else {
+rv = mURI->GetUserPass(buf);
+if (NS_FAILED(rv)) return rv;
+if (!buf.IsEmpty() && ((strncmp(mSpec.get(), "http:", 5) == 0) ||
+strncmp(mSpec.get(), "https:", 6) == 0)) {
+nsCOMPtr<nsIURI> tempURI;
+rv = mURI->Clone(getter_AddRefs(tempURI));
+if (NS_FAILED(rv)) return rv;
+rv = tempURI->SetUserPass(EmptyCString());
+if (NS_FAILED(rv)) return rv;
+rv = tempURI->GetAsciiSpec(path);
+if (NS_FAILED(rv)) return rv;
+requestURI = &path;
+}
+else
+requestURI = &mSpec;
+mRequestHead.SetVersion(gHttpHandler->ProxyHttpVersion());
+}
+// trim off the #ref portion if any...
+int32_t ref = requestURI->FindChar('#');
+if (ref != kNotFound)
+requestURI->SetLength(ref);
+mRequestHead.SetRequestURI(*requestURI);
+// set the request time for cache expiration calculations
+mRequestTime = NowInSeconds();
+mRequestTimeInitialized = true;
+// if doing a reload, force end-to-end
+if (mLoadFlags & LOAD_BYPASS_CACHE) {
+// We need to send 'Pragma:no-cache' to inhibit proxy caching even if
+// no proxy is configured since we might be talking with a transparent
+// proxy, i.e. one that operates at the network level.  See bug #14772.
+mRequestHead.SetHeaderOnce(nsHttp::Pragma, "no-cache", true);
+// If we're configured to speak HTTP/1.1 then also send 'Cache-control:
+// no-cache'
+if (mRequestHead.Version() >= NS_HTTP_VERSION_1_1)
+mRequestHead.SetHeaderOnce(nsHttp::Cache_Control, "no-cache", true);
+}
+else if ((mLoadFlags & VALIDATE_ALWAYS) && !mCacheEntryIsWriteOnly) {
+// We need to send 'Cache-Control: max-age=0' to force each cache along
+// the path to the origin server to revalidate its own entry, if any,
+// with the next cache or server.  See bug #84847.
+//
+// If we're configured to speak HTTP/1.0 then just send 'Pragma: no-cache'
+if (mRequestHead.Version() >= NS_HTTP_VERSION_1_1)
+mRequestHead.SetHeaderOnce(nsHttp::Cache_Control, "max-age=0", true);
+else
+mRequestHead.SetHeaderOnce(nsHttp::Pragma, "no-cache", true);
+}
+if (mResuming) {
+char byteRange[32];
+PR_snprintf(byteRange, sizeof(byteRange), "bytes=%llu-", mStartPos);
+mRequestHead.SetHeader(nsHttp::Range, nsDependentCString(byteRange));
+if (!mEntityID.IsEmpty()) {
+// Also, we want an error if this resource changed in the meantime
+// Format of the entity id is: escaped_etag/size/lastmod
+nsCString::const_iterator start, end, slash;
+mEntityID.BeginReading(start);
+mEntityID.EndReading(end);
+mEntityID.BeginReading(slash);
+if (FindCharInReadable('/', slash, end)) {
+nsAutoCString ifMatch;
+mRequestHead.SetHeader(nsHttp::If_Match,
+NS_UnescapeURL(Substring(start, slash), 0, ifMatch));
+++slash; // Incrementing, so that searching for '/' won't find
+// the same slash again
+}
+if (FindCharInReadable('/', slash, end)) {
+mRequestHead.SetHeader(nsHttp::If_Unmodified_Since,
+Substring(++slash, end));
+}
+}
+}
+// create wrapper for this channel's notification callbacks
+nsCOMPtr<nsIInterfaceRequestor> callbacks;
+NS_NewNotificationCallbacksAggregation(mCallbacks, mLoadGroup,
+getter_AddRefs(callbacks));
+if (!callbacks)
+return NS_ERROR_OUT_OF_MEMORY;
+// create the transaction object
+mTransaction = new nsHttpTransaction();
+if (!mTransaction)
+return NS_ERROR_OUT_OF_MEMORY;
+// See bug #466080. Transfer LOAD_ANONYMOUS flag to socket-layer.
+if (mLoadFlags & LOAD_ANONYMOUS)
+mCaps |= NS_HTTP_LOAD_ANONYMOUS;
+if (mTimingEnabled)
+mCaps |= NS_HTTP_TIMING_ENABLED;
+if (mUpgradeProtocolCallback) {
+mRequestHead.SetHeader(nsHttp::Upgrade, mUpgradeProtocol, false);
+mRequestHead.SetHeaderOnce(nsHttp::Connection,
+nsHttp::Upgrade.get(),
+true);
+mCaps |=  NS_HTTP_STICKY_CONNECTION;
+mCaps &= ~NS_HTTP_ALLOW_PIPELINING;
+mCaps &= ~NS_HTTP_ALLOW_KEEPALIVE;
+mCaps |=  NS_HTTP_DISALLOW_SPDY;
+}
+nsCOMPtr<nsIAsyncInputStream> responseStream;
+rv = mTransaction->Init(mCaps, mConnectionInfo, &mRequestHead,
+mUploadStream, mUploadStreamHasHeaders,
+NS_GetCurrentThread(), callbacks, this,
+getter_AddRefs(responseStream));
+if (NS_FAILED(rv)) {
+mTransaction = nullptr;
+return rv;
+}
+SetupTransactionLoadGroupInfo();
+rv = nsInputStreamPump::Create(getter_AddRefs(mTransactionPump),
+responseStream);
+return rv;
+}
+// NOTE: This function duplicates code from nsBaseChannel. This will go away
+// once HTTP uses nsBaseChannel (part of bug 312760)
+static void
+CallTypeSniffers(void *aClosure, const uint8_t *aData, uint32_t aCount)
+{
+nsIChannel *chan = static_cast<nsIChannel*>(aClosure);
+nsAutoCString newType;
+NS_SniffContent(NS_CONTENT_SNIFFER_CATEGORY, chan, aData, aCount, newType);
+if (!newType.IsEmpty()) {
+chan->SetContentType(newType);
+}
+}
+nsresult
+nsHttpChannel::CallOnStartRequest()
+{
+nsresult rv;
+mTracingEnabled = false;
+// Allow consumers to override our content type
+if (mLoadFlags & LOAD_CALL_CONTENT_SNIFFERS) {
+// NOTE: We can have both a txn pump and a cache pump when the cache
+// content is partial. In that case, we need to read from the cache,
+// because that's the one that has the initial contents. If that fails
+// then give the transaction pump a shot.
+nsIChannel* thisChannel = static_cast<nsIChannel*>(this);
+bool typeSniffersCalled = false;
+if (mCachePump) {
+typeSniffersCalled =
+NS_SUCCEEDED(mCachePump->PeekStream(CallTypeSniffers, thisChannel));
+}
+if (!typeSniffersCalled && mTransactionPump) {
+mTransactionPump->PeekStream(CallTypeSniffers, thisChannel);
+}
+}
+bool shouldSniff = mResponseHead && (mResponseHead->ContentType().IsEmpty() ||
+((mResponseHead->ContentType().EqualsLiteral(APPLICATION_OCTET_STREAM) &&
+(mLoadFlags & LOAD_TREAT_APPLICATION_OCTET_STREAM_AS_UNKNOWN))));
+if (shouldSniff) {
+MOZ_ASSERT(mConnectionInfo, "Should have connection info here");
+if (!mContentTypeHint.IsEmpty())
+mResponseHead->SetContentType(mContentTypeHint);
+else if (mResponseHead->Version() == NS_HTTP_VERSION_0_9 &&
+mConnectionInfo->Port() != mConnectionInfo->DefaultPort())
+mResponseHead->SetContentType(NS_LITERAL_CSTRING(TEXT_PLAIN));
+else {
+// Uh-oh.  We had better find out what type we are!
+// XXX This does not work with content-encodings...  but
+// neither does applying the conversion from the URILoader
+nsCOMPtr<nsIStreamConverterService> serv;
+rv = gHttpHandler->
+GetStreamConverterService(getter_AddRefs(serv));
+// If we failed, we just fall through to the "normal" case
+if (NS_SUCCEEDED(rv)) {
+nsCOMPtr<nsIStreamListener> converter;
+rv = serv->AsyncConvertData(UNKNOWN_CONTENT_TYPE,
+"*/*",
+mListener,
+mListenerContext,
+getter_AddRefs(converter));
+if (NS_SUCCEEDED(rv)) {
+mListener = converter;
+}
+}
+}
+}
+if (mResponseHead && mResponseHead->ContentCharset().IsEmpty())
+mResponseHead->SetContentCharset(mContentCharsetHint);
+if (mResponseHead && mCacheEntry) {
+// If we have a cache entry, set its predicted size to ContentLength to
+// avoid caching an entry that will exceed the max size limit.
+rv = mCacheEntry->SetPredictedDataSize(
+mResponseHead->ContentLength());
+if (NS_ERROR_FILE_TOO_BIG == rv) {
+mCacheEntry = nullptr;
+LOG(("  entry too big, throwing away"));
+} else {
+NS_ENSURE_SUCCESS(rv, rv);
+}
+}
+LOG(("  calling mListener->OnStartRequest\n"));
+if (mListener) {
+rv = mListener->OnStartRequest(this, mListenerContext);
+if (NS_FAILED(rv))
+return rv;
+} else {
+NS_WARNING("OnStartRequest skipped because of null listener");
+}
+// install stream converter if required
+rv = ApplyContentConversions();
+if (NS_FAILED(rv)) return rv;
+rv = EnsureAssocReq();
+if (NS_FAILED(rv))
+return rv;
+// if this channel is for a download, close off access to the cache.
+if (mCacheEntry && mChannelIsForDownload) {
+mCacheEntry->AsyncDoom(nullptr);
+// We must keep the cache entry in case of partial request.
+// Concurrent access is the same, we need the entry in
+// OnStopRequest.
+if (!mCachedContentIsPartial && !mConcurentCacheAccess)
+CloseCacheEntry(false);
+}
+if (!mCanceled) {
+// create offline cache entry if offline caching was requested
+if (ShouldUpdateOfflineCacheEntry()) {
+LOG(("writing to the offline cache"));
+rv = InitOfflineCacheEntry();
+if (NS_FAILED(rv)) return rv;
+// InitOfflineCacheEntry may have closed mOfflineCacheEntry
+if (mOfflineCacheEntry) {
+rv = InstallOfflineCacheListener();
+if (NS_FAILED(rv)) return rv;
+}
+} else if (mApplicationCacheForWrite) {
+LOG(("offline cache is up to date, not updating"));
+CloseOfflineCacheEntry();
+}
+}
+return NS_OK;
+}
+nsresult
+nsHttpChannel::ProcessFailedProxyConnect(uint32_t httpStatus)
+{
+// Failure to set up a proxy tunnel via CONNECT means one of the following:
+// 1) Proxy wants authorization, or forbids.
+// 2) DNS at proxy couldn't resolve target URL.
+// 3) Proxy connection to target failed or timed out.
+// 4) Eve intercepted our CONNECT, and is replying with malicious HTML.
+//
+// Our current architecture would parse the proxy's response content with
+// the permission of the target URL.  Given #4, we must avoid rendering the
+// body of the reply, and instead give the user a (hopefully helpful)
+// boilerplate error page, based on just the HTTP status of the reply.
+MOZ_ASSERT(mConnectionInfo->UsingConnect(),
+"proxy connect failed but not using CONNECT?");
+nsresult rv;
+switch (httpStatus)
+{
+case 300: case 301: case 302: case 303: case 307: case 308:
+// Bad redirect: not top-level, or it's a POST, bad/missing Location,
+// or ProcessRedirect() failed for some other reason.  Legal
+// redirects that fail because site not available, etc., are handled
+// elsewhere, in the regular codepath.
+rv = NS_ERROR_CONNECTION_REFUSED;
+break;
+case 403: // HTTP/1.1: "Forbidden"
+case 407: // ProcessAuthentication() failed
+case 501: // HTTP/1.1: "Not Implemented"
+// user sees boilerplate Mozilla "Proxy Refused Connection" page.
+rv = NS_ERROR_PROXY_CONNECTION_REFUSED;
+break;
+// Squid sends 404 if DNS fails (regular 404 from target is tunneled)
+case 404: // HTTP/1.1: "Not Found"
+// RFC 2616: "some deployed proxies are known to return 400 or 500 when
+// DNS lookups time out."  (Squid uses 500 if it runs out of sockets: so
+// we have a conflict here).
+case 400: // HTTP/1.1 "Bad Request"
+case 500: // HTTP/1.1: "Internal Server Error"
+/* User sees: "Address Not Found: Firefox can't find the server at
+* www.foo.com."
+*/
+rv = NS_ERROR_UNKNOWN_HOST;
+break;
+case 502: // HTTP/1.1: "Bad Gateway" (invalid resp from target server)
+// Squid returns 503 if target request fails for anything but DNS.
+case 503: // HTTP/1.1: "Service Unavailable"
+/* User sees: "Failed to Connect:
+*  Firefox can't establish a connection to the server at
+*  www.foo.com.  Though the site seems valid, the browser
+*  was unable to establish a connection."
+*/
+rv = NS_ERROR_CONNECTION_REFUSED;
+break;
+// RFC 2616 uses 504 for both DNS and target timeout, so not clear what to
+// do here: picking target timeout, as DNS covered by 400/404/500
+case 504: // HTTP/1.1: "Gateway Timeout"
+// user sees: "Network Timeout: The server at www.foo.com
+//              is taking too long to respond."
+rv = NS_ERROR_NET_TIMEOUT;
+break;
+// Confused proxy server or malicious response
+default:
+rv = NS_ERROR_PROXY_CONNECTION_REFUSED;
+break;
+}
+LOG(("Cancelling failed proxy CONNECT [this=%p httpStatus=%u]\n",
+this, httpStatus));
+Cancel(rv);
+CallOnStartRequest();
+return rv;
+}
+/**
+* Decide whether or not to remember Strict-Transport-Security, and whether
+* or not to enforce channel integrity.
+*
+* @return NS_ERROR_FAILURE if there's security information missing even though
+*             it's an HTTPS connection.
+*/
+nsresult
+nsHttpChannel::ProcessSTSHeader()
+{
+nsresult rv;
+bool isHttps = false;
+rv = mURI->SchemeIs("https", &isHttps);
+NS_ENSURE_SUCCESS(rv, rv);
+// If this channel is not loading securely, STS doesn't do anything.
+// The upgrade to HTTPS takes place earlier in the channel load process.
+if (!isHttps)
+return NS_OK;
+nsAutoCString asciiHost;
+rv = mURI->GetAsciiHost(asciiHost);
+NS_ENSURE_SUCCESS(rv, NS_OK);
+// If the channel is not a hostname, but rather an IP, STS doesn't do
+// anything.
+PRNetAddr hostAddr;
+if (PR_SUCCESS == PR_StringToNetAddr(asciiHost.get(), &hostAddr))
+return NS_OK;
+nsISiteSecurityService* sss = gHttpHandler->GetSSService();
+NS_ENSURE_TRUE(sss, NS_ERROR_OUT_OF_MEMORY);
+// mSecurityInfo may not always be present, and if it's not then it is okay
+// to just disregard any STS headers since we know nothing about the
+// security of the connection.
+NS_ENSURE_TRUE(mSecurityInfo, NS_OK);
+// Check the trustworthiness of the channel (are there any cert errors?)
+// If there are certificate errors, we still load the data, we just ignore
+// any STS headers that are present.
+bool tlsIsBroken = false;
+rv = sss->ShouldIgnoreHeaders(mSecurityInfo, &tlsIsBroken);
+NS_ENSURE_SUCCESS(rv, NS_OK);
+// If this was already an STS host, the connection should have been aborted
+// by the bad cert handler in the case of cert errors.  If it didn't abort the connection,
+// there's probably something funny going on.
+// If this wasn't an STS host, errors are allowed, but no more STS processing
+// will happen during the session.
+bool wasAlreadySTSHost;
+uint32_t flags =
+NS_UsePrivateBrowsing(this) ? nsISocketProvider::NO_PERMANENT_STORAGE : 0;
+rv = sss->IsSecureURI(nsISiteSecurityService::HEADER_HSTS, mURI, flags,
+&wasAlreadySTSHost);
+// Failure here means STS is broken.  Don't prevent the load, but this
+// shouldn't fail.
+NS_ENSURE_SUCCESS(rv, NS_OK);
+MOZ_ASSERT(!(wasAlreadySTSHost && tlsIsBroken),
+"connection should have been aborted by nss-bad-cert-handler");
+// Any STS header is ignored if the channel is not trusted due to
+// certificate errors (STS Spec 7.1) -- there is nothing else to do, and
+// the load may progress.
+if (tlsIsBroken) {
+LOG(("STS: Transport layer is not trustworthy, ignoring "
+"STS headers and continuing load\n"));
+return NS_OK;
+}
+// If there's a STS header, process it (STS Spec 7.1).  At this point in
+// processing, the channel is trusted, so the header should not be ignored.
+const nsHttpAtom atom = nsHttp::ResolveAtom("Strict-Transport-Security");
+nsAutoCString stsHeader;
+rv = mResponseHead->GetHeader(atom, stsHeader);
+if (rv == NS_ERROR_NOT_AVAILABLE) {
+LOG(("STS: No STS header, continuing load.\n"));
+return NS_OK;
+}
+// All other failures are fatal.
+NS_ENSURE_SUCCESS(rv, rv);
+rv = sss->ProcessHeader(nsISiteSecurityService::HEADER_HSTS, mURI,
+stsHeader.get(), flags, nullptr, nullptr);
+if (NS_FAILED(rv)) {
+AddSecurityMessage(NS_LITERAL_STRING("InvalidSTSHeaders"),
+NS_LITERAL_STRING("Invalid HSTS Headers"));
+LOG(("STS: Failed to parse STS header, continuing load.\n"));
+}
+return NS_OK;
+}
+bool
+nsHttpChannel::IsHTTPS()
+{
+bool isHttps;
+if (NS_FAILED(mURI->SchemeIs("https", &isHttps)) || !isHttps)
+return false;
+return true;
+}
+void
+nsHttpChannel::ProcessSSLInformation()
+{
+// If this is HTTPS, record any use of RSA so that Key Exchange Algorithm
+// can be whitelisted for TLS False Start in future sessions. We could
+// do the same for DH but its rarity doesn't justify the lookup.
+if (mCanceled || NS_FAILED(mStatus) || !mSecurityInfo ||
+!IsHTTPS() || mPrivateBrowsing)
+return;
+nsCOMPtr<nsISSLSocketControl> ssl = do_QueryInterface(mSecurityInfo);
+nsCOMPtr<nsISSLStatusProvider> statusProvider =
+do_QueryInterface(mSecurityInfo);
+if (!ssl || !statusProvider)
+return;
+nsCOMPtr<nsISSLStatus> sslstat;
+statusProvider->GetSSLStatus(getter_AddRefs(sslstat));
+if (!sslstat)
+return;
+// If certificate exceptions are being used don't record this information
+// in the permission manager.
+bool trustCheck;
+if (NS_FAILED(sslstat->GetIsDomainMismatch(&trustCheck)) || trustCheck)
+return;
+if (NS_FAILED(sslstat->GetIsNotValidAtThisTime(&trustCheck)) || trustCheck)
+return;
+if (NS_FAILED(sslstat->GetIsUntrusted(&trustCheck)) || trustCheck)
+return;
+int16_t kea = ssl->GetKEAUsed();
+nsIPrincipal *principal = GetPrincipal();
+if (!principal)
+return;
+// set a permission manager flag that future transactions can
+// use via RetrieveSSLOptions(()
+nsCOMPtr<nsIPermissionManager> permMgr =
+do_GetService(NS_PERMISSIONMANAGER_CONTRACTID);
+if (!permMgr)
+return;
+// Allow this to stand for a week
+int64_t expireTime = (PR_Now() / PR_USEC_PER_MSEC) +
+(86400 * 7 * PR_MSEC_PER_SEC);
+if (kea == ssl_kea_rsa) {
+permMgr->AddFromPrincipal(principal, "falsestart-rsa",
+nsIPermissionManager::ALLOW_ACTION,
+nsIPermissionManager::EXPIRE_TIME,
+expireTime);
+LOG(("nsHttpChannel::ProcessSSLInformation [this=%p] "
+"falsestart-rsa permission granted for this host\n", this));
+} else {
+permMgr->RemoveFromPrincipal(principal, "falsestart-rsa");
+}
+}
+nsresult
+nsHttpChannel::ProcessResponse()
+{
+nsresult rv;
+uint32_t httpStatus = mResponseHead->Status();
+// Gather data on whether the transaction and page (if this is
+// the initial page load) is being loaded with SSL.
+Telemetry::Accumulate(Telemetry::HTTP_TRANSACTION_IS_SSL,
+mConnectionInfo->UsingSSL());
+if (mLoadFlags & LOAD_INITIAL_DOCUMENT_URI) {
+Telemetry::Accumulate(Telemetry::HTTP_PAGELOAD_IS_SSL,
+mConnectionInfo->UsingSSL());
+}
+LOG(("nsHttpChannel::ProcessResponse [this=%p httpStatus=%u]\n",
+this, httpStatus));
+if (mTransaction->ProxyConnectFailed()) {
+// Only allow 407 (authentication required) to continue
+if (httpStatus != 407)
+return ProcessFailedProxyConnect(httpStatus);
+// If proxy CONNECT response needs to complete, wait to process connection
+// for Strict-Transport-Security.
+} else {
+// Given a successful connection, process any STS data that's relevant.
+rv = ProcessSTSHeader();
+MOZ_ASSERT(NS_SUCCEEDED(rv), "ProcessSTSHeader failed, continuing load.");
+}
+MOZ_ASSERT(!mCachedContentIsValid);
+ProcessSSLInformation();
+// notify "http-on-examine-response" observers
+gHttpHandler->OnExamineResponse(this);
+SetCookie(mResponseHead->PeekHeader(nsHttp::Set_Cookie));
+// handle unused username and password in url (see bug 232567)
+if (httpStatus != 401 && httpStatus != 407) {
+if (!mAuthRetryPending)
+mAuthProvider->CheckForSuperfluousAuth();
+if (mCanceled)
+return CallOnStartRequest();
+// reset the authentication's current continuation state because our
+// last authentication attempt has been completed successfully
+mAuthProvider->Disconnect(NS_ERROR_ABORT);
+mAuthProvider = nullptr;
+LOG(("  continuation state has been reset"));
+}
+bool successfulReval = false;
+// handle different server response categories.  Note that we handle
+// caching or not caching of error pages in
+// nsHttpResponseHead::MustValidate; if you change this switch, update that
+// one
+switch (httpStatus) {
+case 200:
+case 203:
+// Per RFC 2616, 14.35.2, "A server MAY ignore the Range header".
+// So if a server does that and sends 200 instead of 206 that we
+// expect, notify our caller.
+// However, if we wanted to start from the beginning, let it go through
+if (mResuming && mStartPos != 0) {
+LOG(("Server ignored our Range header, cancelling [this=%p]\n", this));
+Cancel(NS_ERROR_NOT_RESUMABLE);
+rv = CallOnStartRequest();
+break;
+}
+// these can normally be cached
+rv = ProcessNormal();
+MaybeInvalidateCacheEntryForSubsequentGet();
+break;
+case 206:
+if (mCachedContentIsPartial) // an internal byte range request...
+rv = ProcessPartialContent();
+else {
+mCacheInputStream.CloseAndRelease();
+rv = ProcessNormal();
+}
+break;
+case 300:
+case 301:
+case 302:
+case 307:
+case 308:
+case 303:
+#if 0
+case 305: // disabled as a security measure (see bug 187996).
+#endif
+// don't store the response body for redirects
+MaybeInvalidateCacheEntryForSubsequentGet();
+PushRedirectAsyncFunc(&nsHttpChannel::ContinueProcessResponse);
+rv = AsyncProcessRedirection(httpStatus);
+if (NS_FAILED(rv)) {
+PopRedirectAsyncFunc(&nsHttpChannel::ContinueProcessResponse);
+LOG(("AsyncProcessRedirection failed [rv=%x]\n", rv));
+// don't cache failed redirect responses.
+if (mCacheEntry)
+mCacheEntry->AsyncDoom(nullptr);
+if (DoNotRender3xxBody(rv)) {
+mStatus = rv;
+DoNotifyListener();
+} else {
+rv = ContinueProcessResponse(rv);
+}
+}
+break;
+case 304:
+rv = ProcessNotModified();
+if (NS_FAILED(rv)) {
+LOG(("ProcessNotModified failed [rv=%x]\n", rv));
+mCacheInputStream.CloseAndRelease();
+rv = ProcessNormal();
+}
+else {
+successfulReval = true;
+}
+break;
+case 401:
+case 407:
+rv = mAuthProvider->ProcessAuthentication(
+httpStatus, mConnectionInfo->UsingSSL() &&
+mTransaction->ProxyConnectFailed());
+if (rv == NS_ERROR_IN_PROGRESS)  {
+// authentication prompt has been invoked and result
+// is expected asynchronously
+mAuthRetryPending = true;
+if (httpStatus == 407 || mTransaction->ProxyConnectFailed())
+mProxyAuthPending = true;
+// suspend the transaction pump to stop receiving the
+// unauthenticated content data. We will throw that data
+// away when user provides credentials or resume the pump
+// when user refuses to authenticate.
+LOG(("Suspending the transaction, asynchronously prompting for credentials"));
+mTransactionPump->Suspend();
+rv = NS_OK;
+}
+else if (NS_FAILED(rv)) {
+LOG(("ProcessAuthentication failed [rv=%x]\n", rv));
+if (mTransaction->ProxyConnectFailed())
+return ProcessFailedProxyConnect(httpStatus);
+if (!mAuthRetryPending)
+mAuthProvider->CheckForSuperfluousAuth();
+rv = ProcessNormal();
+}
+else
+mAuthRetryPending = true; // see DoAuthRetry
+break;
+default:
+rv = ProcessNormal();
+MaybeInvalidateCacheEntryForSubsequentGet();
+break;
+}
+CacheDisposition cacheDisposition;
+if (!mDidReval)
+cacheDisposition = kCacheMissed;
+else if (successfulReval)
+cacheDisposition = kCacheHitViaReval;
+else
+cacheDisposition = kCacheMissedViaReval;
+AccumulateCacheHitTelemetry(cacheDisposition);
+return rv;
+}
+nsresult
+nsHttpChannel::ContinueProcessResponse(nsresult rv)
+{
+bool doNotRender = DoNotRender3xxBody(rv);
+if (rv == NS_ERROR_DOM_BAD_URI && mRedirectURI) {
+bool isHTTP = false;
+if (NS_FAILED(mRedirectURI->SchemeIs("http", &isHTTP)))
+isHTTP = false;
+if (!isHTTP && NS_FAILED(mRedirectURI->SchemeIs("https", &isHTTP)))
+isHTTP = false;
+if (!isHTTP) {
+// This was a blocked attempt to redirect and subvert the system by
+// redirecting to another protocol (perhaps javascript:)
+// In that case we want to throw an error instead of displaying the
+// non-redirected response body.
+LOG(("ContinueProcessResponse detected rejected Non-HTTP Redirection"));
+doNotRender = true;
+rv = NS_ERROR_CORRUPTED_CONTENT;
+}
+}
+if (doNotRender) {
+Cancel(rv);
+DoNotifyListener();
+return rv;
+}
+if (NS_SUCCEEDED(rv)) {
+UpdateInhibitPersistentCachingFlag();
+InitCacheEntry();
+CloseCacheEntry(false);
+if (mApplicationCacheForWrite) {
+// Store response in the offline cache
+InitOfflineCacheEntry();
+CloseOfflineCacheEntry();
+}
+return NS_OK;
+}
+LOG(("ContinueProcessResponse got failure result [rv=%x]\n", rv));
+if (mTransaction->ProxyConnectFailed()) {
+return ProcessFailedProxyConnect(mRedirectType);
+}
+return ProcessNormal();
+}
+nsresult
+nsHttpChannel::ProcessNormal()
+{
+nsresult rv;
+LOG(("nsHttpChannel::ProcessNormal [this=%p]\n", this));
+bool succeeded;
+rv = GetRequestSucceeded(&succeeded);
+if (NS_SUCCEEDED(rv) && !succeeded) {
+PushRedirectAsyncFunc(&nsHttpChannel::ContinueProcessNormal);
+bool waitingForRedirectCallback;
+(void)ProcessFallback(&waitingForRedirectCallback);
+if (waitingForRedirectCallback) {
+// The transaction has been suspended by ProcessFallback.
+return NS_OK;
+}
+PopRedirectAsyncFunc(&nsHttpChannel::ContinueProcessNormal);
+}
+return ContinueProcessNormal(NS_OK);
+}
+nsresult
+nsHttpChannel::ContinueProcessNormal(nsresult rv)
+{
+if (NS_FAILED(rv)) {
+// Fill the failure status here, we have failed to fall back, thus we
+// have to report our status as failed.
+mStatus = rv;
+DoNotifyListener();
+return rv;
+}
+if (mFallingBack) {
+// Do not continue with normal processing, fallback is in
+// progress now.
+return NS_OK;
+}
+// if we're here, then any byte-range requests failed to result in a partial
+// response.  we must clear this flag to prevent BufferPartialContent from
+// being called inside our OnDataAvailable (see bug 136678).
+mCachedContentIsPartial = false;
+ClearBogusContentEncodingIfNeeded();
+UpdateInhibitPersistentCachingFlag();
+// this must be called before firing OnStartRequest, since http clients,
+// such as imagelib, expect our cache entry to already have the correct
+// expiration time (bug 87710).
+if (mCacheEntry) {
+rv = InitCacheEntry();
+if (NS_FAILED(rv))
+CloseCacheEntry(true);
+}
+// Check that the server sent us what we were asking for
+if (mResuming) {
+// Create an entity id from the response
+nsAutoCString id;
+rv = GetEntityID(id);
+if (NS_FAILED(rv)) {
+// If creating an entity id is not possible -> error
+Cancel(NS_ERROR_NOT_RESUMABLE);
+}
+else if (mResponseHead->Status() != 206 &&
+mResponseHead->Status() != 200) {
+// Probably 404 Not Found, 412 Precondition Failed or
+// 416 Invalid Range -> error
+LOG(("Unexpected response status while resuming, aborting [this=%p]\n",
+this));
+Cancel(NS_ERROR_ENTITY_CHANGED);
+}
+// If we were passed an entity id, verify it's equal to the server's
+else if (!mEntityID.IsEmpty()) {
+if (!mEntityID.Equals(id)) {
+LOG(("Entity mismatch, expected '%s', got '%s', aborting [this=%p]",
+mEntityID.get(), id.get(), this));
+Cancel(NS_ERROR_ENTITY_CHANGED);
+}
+}
+}
+rv = CallOnStartRequest();
+if (NS_FAILED(rv)) return rv;
+// install cache listener if we still have a cache entry open
+if (mCacheEntry && !mLoadedFromApplicationCache) {
+rv = InstallCacheListener();
+if (NS_FAILED(rv)) return rv;
+}
+return NS_OK;
+}
+nsresult
+nsHttpChannel::PromptTempRedirect()
+{
+if (!gHttpHandler->PromptTempRedirect()) {
+return NS_OK;
+}
+nsresult rv;
+nsCOMPtr<nsIStringBundleService> bundleService =
+do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv);
+if (NS_FAILED(rv)) return rv;
+nsCOMPtr<nsIStringBundle> stringBundle;
+rv = bundleService->CreateBundle(NECKO_MSGS_URL, getter_AddRefs(stringBundle));
+if (NS_FAILED(rv)) return rv;
+nsXPIDLString messageString;
+rv = stringBundle->GetStringFromName(MOZ_UTF16("RepostFormData"), getter_Copies(messageString));
+// GetStringFromName can return NS_OK and nullptr messageString.
+if (NS_SUCCEEDED(rv) && messageString) {
+bool repost = false;
+nsCOMPtr<nsIPrompt> prompt;
+GetCallback(prompt);
+if (!prompt)
+return NS_ERROR_NO_INTERFACE;
+prompt->Confirm(nullptr, messageString, &repost);
+if (!repost)
+return NS_ERROR_FAILURE;
+}
+return rv;
+}
+nsresult
+nsHttpChannel::ProxyFailover()
+{
+LOG(("nsHttpChannel::ProxyFailover [this=%p]\n", this));
+nsresult rv;
+nsCOMPtr<nsIProtocolProxyService> pps =
+do_GetService(NS_PROTOCOLPROXYSERVICE_CONTRACTID, &rv);
+if (NS_FAILED(rv))
+return rv;
+nsCOMPtr<nsIProxyInfo> pi;
+rv = pps->GetFailoverForProxy(mConnectionInfo->ProxyInfo(), mURI, mStatus,
+getter_AddRefs(pi));
+if (NS_FAILED(rv))
+return rv;
+// XXXbz so where does this codepath remove us from the loadgroup,
+// exactly?
+return AsyncDoReplaceWithProxy(pi);
+}
+void
+nsHttpChannel::HandleAsyncRedirectChannelToHttps()
+{
+NS_PRECONDITION(!mCallOnResume, "How did that happen?");
+if (mSuspendCount) {
+LOG(("Waiting until resume to do async redirect to https [this=%p]\n", this));
+mCallOnResume = &nsHttpChannel::HandleAsyncRedirectChannelToHttps;
+return;
+}
+nsresult rv = StartRedirectChannelToHttps();
+if (NS_FAILED(rv))
+ContinueAsyncRedirectChannelToURI(rv);
+}
+nsresult
+nsHttpChannel::StartRedirectChannelToHttps()
+{
+nsresult rv = NS_OK;
+LOG(("nsHttpChannel::HandleAsyncRedirectChannelToHttps() [STS]\n"));
+nsCOMPtr<nsIURI> upgradedURI;
+rv = mURI->Clone(getter_AddRefs(upgradedURI));
+NS_ENSURE_SUCCESS(rv,rv);
+upgradedURI->SetScheme(NS_LITERAL_CSTRING("https"));
+int32_t oldPort = -1;
+rv = mURI->GetPort(&oldPort);
+if (NS_FAILED(rv)) return rv;
+// Keep any nonstandard ports so only the scheme is changed.
+// For example:
+//  http://foo.com:80 -> https://foo.com:443
+//  http://foo.com:81 -> https://foo.com:81
+if (oldPort == 80 || oldPort == -1)
+upgradedURI->SetPort(-1);
+else
+upgradedURI->SetPort(oldPort);
+return StartRedirectChannelToURI(upgradedURI,
+nsIChannelEventSink::REDIRECT_PERMANENT);
+}
+void
+nsHttpChannel::HandleAsyncAPIRedirect()
+{
+NS_PRECONDITION(!mCallOnResume, "How did that happen?");
+NS_PRECONDITION(mAPIRedirectToURI, "How did that happen?");
+if (mSuspendCount) {
+LOG(("Waiting until resume to do async API redirect [this=%p]\n", this));
+mCallOnResume = &nsHttpChannel::HandleAsyncAPIRedirect;
+return;
+}
+nsresult rv = StartRedirectChannelToURI(mAPIRedirectToURI,
+nsIChannelEventSink::REDIRECT_PERMANENT);
+if (NS_FAILED(rv))
+ContinueAsyncRedirectChannelToURI(rv);
+return;
+}
+nsresult
+nsHttpChannel::StartRedirectChannelToURI(nsIURI *upgradedURI, uint32_t flags)
+{
+nsresult rv = NS_OK;
+LOG(("nsHttpChannel::StartRedirectChannelToURI()\n"));
+nsCOMPtr<nsIChannel> newChannel;
+nsCOMPtr<nsIIOService> ioService;
+rv = gHttpHandler->GetIOService(getter_AddRefs(ioService));
+NS_ENSURE_SUCCESS(rv, rv);
+rv = ioService->NewChannelFromURI(upgradedURI, getter_AddRefs(newChannel));
+NS_ENSURE_SUCCESS(rv, rv);
+rv = SetupReplacementChannel(upgradedURI, newChannel, true);
+NS_ENSURE_SUCCESS(rv, rv);
+// Inform consumers about this fake redirect
+mRedirectChannel = newChannel;
+PushRedirectAsyncFunc(
+&nsHttpChannel::ContinueAsyncRedirectChannelToURI);
+rv = gHttpHandler->AsyncOnChannelRedirect(this, newChannel, flags);
+if (NS_SUCCEEDED(rv))
+rv = WaitForRedirectCallback();
+if (NS_FAILED(rv)) {
+AutoRedirectVetoNotifier notifier(this);
+/* Remove the async call to ContinueAsyncRedirectChannelToURI().
+* It is called directly by our callers upon return (to clean up
+* the failed redirect). */
+PopRedirectAsyncFunc(
+&nsHttpChannel::ContinueAsyncRedirectChannelToURI);
+}
+return rv;
+}
+nsresult
+nsHttpChannel::ContinueAsyncRedirectChannelToURI(nsresult rv)
+{
+if (NS_SUCCEEDED(rv))
+rv = OpenRedirectChannel(rv);
+if (NS_FAILED(rv)) {
+// Fill the failure status here, the update to https had been vetoed
+// but from the security reasons we have to discard the whole channel
+// load.
+mStatus = rv;
+}
+if (mLoadGroup)
+mLoadGroup->RemoveRequest(this, nullptr, mStatus);
+if (NS_FAILED(rv)) {
+// We have to manually notify the listener because there is not any pump
+// that would call our OnStart/StopRequest after resume from waiting for
+// the redirect callback.
+DoNotifyListener();
+}
+return rv;
+}
+nsresult
+nsHttpChannel::OpenRedirectChannel(nsresult rv)
+{
+AutoRedirectVetoNotifier notifier(this);
+// Make sure to do this _after_ calling OnChannelRedirect
+mRedirectChannel->SetOriginalURI(mOriginalURI);
+// And now, notify observers the deprecated way
+nsCOMPtr<nsIHttpEventSink> httpEventSink;
+GetCallback(httpEventSink);
+if (httpEventSink) {
+// NOTE: nsIHttpEventSink is only used for compatibility with pre-1.8
+// versions.
+rv = httpEventSink->OnRedirect(this, mRedirectChannel);
+if (NS_FAILED(rv)) {
+return rv;
+}
+}
+// open new channel
+rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);
+if (NS_FAILED(rv)) {
+return rv;
+}
+mStatus = NS_BINDING_REDIRECTED;
+notifier.RedirectSucceeded();
+ReleaseListeners();
+return NS_OK;
+}
+nsresult
+nsHttpChannel::AsyncDoReplaceWithProxy(nsIProxyInfo* pi)
+{
+LOG(("nsHttpChannel::AsyncDoReplaceWithProxy [this=%p pi=%p]", this, pi));
+nsresult rv;
+nsCOMPtr<nsIChannel> newChannel;
+rv = gHttpHandler->NewProxiedChannel(mURI, pi, mProxyResolveFlags,
+mProxyURI, getter_AddRefs(newChannel));
+if (NS_FAILED(rv))
+return rv;
+rv = SetupReplacementChannel(mURI, newChannel, true);
+if (NS_FAILED(rv))
+return rv;
+// Inform consumers about this fake redirect
+mRedirectChannel = newChannel;
+uint32_t flags = nsIChannelEventSink::REDIRECT_INTERNAL;
+PushRedirectAsyncFunc(&nsHttpChannel::ContinueDoReplaceWithProxy);
+rv = gHttpHandler->AsyncOnChannelRedirect(this, newChannel, flags);
+if (NS_SUCCEEDED(rv))
+rv = WaitForRedirectCallback();
+if (NS_FAILED(rv)) {
+AutoRedirectVetoNotifier notifier(this);
+PopRedirectAsyncFunc(&nsHttpChannel::ContinueDoReplaceWithProxy);
+}
+return rv;
+}
+nsresult
+nsHttpChannel::ContinueDoReplaceWithProxy(nsresult rv)
+{
+AutoRedirectVetoNotifier notifier(this);
+if (NS_FAILED(rv))
+return rv;
+NS_PRECONDITION(mRedirectChannel, "No redirect channel?");
+// Make sure to do this _after_ calling OnChannelRedirect
+mRedirectChannel->SetOriginalURI(mOriginalURI);
+// open new channel
+rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);
+if (NS_FAILED(rv))
+return rv;
+mStatus = NS_BINDING_REDIRECTED;
+notifier.RedirectSucceeded();
+ReleaseListeners();
+return rv;
+}
+nsresult
+nsHttpChannel::ResolveProxy()
+{
+LOG(("nsHttpChannel::ResolveProxy [this=%p]\n", this));
+nsresult rv;
+nsCOMPtr<nsIProtocolProxyService> pps =
+do_GetService(NS_PROTOCOLPROXYSERVICE_CONTRACTID, &rv);
+if (NS_FAILED(rv))
+return rv;
+// using the nsIProtocolProxyService2 allows a minor performance
+// optimization, but if an add-on has only provided the original interface
+// then it is ok to use that version.
+nsCOMPtr<nsIProtocolProxyService2> pps2 = do_QueryInterface(pps);
+if (pps2) {
+rv = pps2->AsyncResolve2(this, mProxyResolveFlags,
+this, getter_AddRefs(mProxyRequest));
+} else {
+rv = pps->AsyncResolve(this, mProxyResolveFlags,
+this, getter_AddRefs(mProxyRequest));
+}
+return rv;
+}
+bool
+nsHttpChannel::ResponseWouldVary(nsICacheEntry* entry) const
+{
+nsresult rv;
+nsAutoCString buf, metaKey;
+mCachedResponseHead->GetHeader(nsHttp::Vary, buf);
+if (!buf.IsEmpty()) {
+NS_NAMED_LITERAL_CSTRING(prefix, "request-");
+// enumerate the elements of the Vary header...
+char *val = buf.BeginWriting(); // going to munge buf
+char *token = nsCRT::strtok(val, NS_HTTP_HEADER_SEPS, &val);
+while (token) {
+LOG(("nsHttpChannel::ResponseWouldVary [channel=%p] " \
+"processing %s\n",
+this, token));
+//
+// if "*", then assume response would vary.  technically speaking,
+// "Vary: header, *" is not permitted, but we allow it anyways.
+//
+// We hash values of cookie-headers for the following reasons:
+//
+//   1- cookies can be very large in size
+//
+//   2- cookies may contain sensitive information.  (for parity with
+//      out policy of not storing Set-cookie headers in the cache
+//      meta data, we likewise do not want to store cookie headers
+//      here.)
+//
+if (*token == '*')
+return true; // if we encounter this, just get out of here
+// build cache meta data key...
+metaKey = prefix + nsDependentCString(token);
+// check the last value of the given request header to see if it has
+// since changed.  if so, then indeed the cached response is invalid.
+nsXPIDLCString lastVal;
+entry->GetMetaDataElement(metaKey.get(), getter_Copies(lastVal));
+LOG(("nsHttpChannel::ResponseWouldVary [channel=%p] "
+"stored value = \"%s\"\n",
+this, lastVal.get()));
+// Look for value of "Cookie" in the request headers
+nsHttpAtom atom = nsHttp::ResolveAtom(token);
+const char *newVal = mRequestHead.PeekHeader(atom);
+if (!lastVal.IsEmpty()) {
+// value for this header in cache, but no value in request
+if (!newVal)
+return true; // yes - response would vary
+// If this is a cookie-header, stored metadata is not
+// the value itself but the hash. So we also hash the
+// outgoing value here in order to compare the hashes
+nsAutoCString hash;
+if (atom == nsHttp::Cookie) {
+rv = Hash(newVal, hash);
+// If hash failed, be conservative (the cached hash
+// exists at this point) and claim response would vary
+if (NS_FAILED(rv))
+return true;
+newVal = hash.get();
+LOG(("nsHttpChannel::ResponseWouldVary [this=%p] " \
+"set-cookie value hashed to %s\n",
+this, newVal));
+}
+if (strcmp(newVal, lastVal))
+return true; // yes, response would vary
+} else if (newVal) { // old value is empty, but newVal is set
+return true;
+}
+// next token...
+token = nsCRT::strtok(val, NS_HTTP_HEADER_SEPS, &val);
+}
+}
+return false;
+}
+// We need to have an implementation of this function just so that we can keep
+// all references to mCallOnResume of type nsHttpChannel:  it's not OK in C++
+// to set a member function ptr to  a base class function.
+void
+nsHttpChannel::HandleAsyncAbort()
+{
+HttpAsyncAborter<nsHttpChannel>::HandleAsyncAbort();
+}
+nsresult
+nsHttpChannel::EnsureAssocReq()
+{
+// Confirm Assoc-Req response header on pipelined transactions
+// per draft-nottingham-http-pipeline-01.txt
+// of the form: GET http://blah.com/foo/bar?qv
+// return NS_OK as long as we don't find a violation
+// (i.e. no header is ok, as are malformed headers, as are
+// transactions that have not been pipelined (unless those have been
+// opted in via pragma))
+if (!mResponseHead)
+return NS_OK;
+const char *assoc_val = mResponseHead->PeekHeader(nsHttp::Assoc_Req);
+if (!assoc_val)
+return NS_OK;
+if (!mTransaction || !mURI)
+return NS_OK;
+if (!mTransaction->PipelinePosition()) {
+// "Pragma: X-Verify-Assoc-Req" can be used to verify even non pipelined
+// transactions. It is used by test harness.
+const char *pragma_val = mResponseHead->PeekHeader(nsHttp::Pragma);
+if (!pragma_val ||
+!nsHttp::FindToken(pragma_val, "X-Verify-Assoc-Req",
+HTTP_HEADER_VALUE_SEPS))
+return NS_OK;
+}
+char *method = net_FindCharNotInSet(assoc_val, HTTP_LWS);
+if (!method)
+return NS_OK;
+bool equals;
+char *endofmethod;
+assoc_val = nullptr;
+endofmethod = net_FindCharInSet(method, HTTP_LWS);
+if (endofmethod)
+assoc_val = net_FindCharNotInSet(endofmethod, HTTP_LWS);
+if (!assoc_val)
+return NS_OK;
+// check the method
+int32_t methodlen = strlen(mRequestHead.Method().get());
+if ((methodlen != (endofmethod - method)) ||
+PL_strncmp(method,
+mRequestHead.Method().get(),
+endofmethod - method)) {
+LOG(("  Assoc-Req failure Method %s", method));
+if (mConnectionInfo)
+gHttpHandler->ConnMgr()->
+PipelineFeedbackInfo(mConnectionInfo,
+nsHttpConnectionMgr::RedCorruptedContent,
+nullptr, 0);
+nsCOMPtr<nsIConsoleService> consoleService =
+do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+if (consoleService) {
+nsAutoString message
+(NS_LITERAL_STRING("Failed Assoc-Req. Received "));
+AppendASCIItoUTF16(
+mResponseHead->PeekHeader(nsHttp::Assoc_Req),
+message);
+message += NS_LITERAL_STRING(" expected method ");
+AppendASCIItoUTF16(mRequestHead.Method().get(), message);
+consoleService->LogStringMessage(message.get());
+}
+if (gHttpHandler->EnforceAssocReq())
+return NS_ERROR_CORRUPTED_CONTENT;
+return NS_OK;
+}
+// check the URL
+nsCOMPtr<nsIURI> assoc_url;
+if (NS_FAILED(NS_NewURI(getter_AddRefs(assoc_url), assoc_val)) ||
+!assoc_url)
+return NS_OK;
+mURI->Equals(assoc_url, &equals);
+if (!equals) {
+LOG(("  Assoc-Req failure URL %s", assoc_val));
+if (mConnectionInfo)
+gHttpHandler->ConnMgr()->
+PipelineFeedbackInfo(mConnectionInfo,
+nsHttpConnectionMgr::RedCorruptedContent,
+nullptr, 0);
+nsCOMPtr<nsIConsoleService> consoleService =
+do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+if (consoleService) {
+nsAutoString message
+(NS_LITERAL_STRING("Failed Assoc-Req. Received "));
+AppendASCIItoUTF16(
+mResponseHead->PeekHeader(nsHttp::Assoc_Req),
+message);
+message += NS_LITERAL_STRING(" expected URL ");
+AppendASCIItoUTF16(mSpec.get(), message);
+consoleService->LogStringMessage(message.get());
+}
+if (gHttpHandler->EnforceAssocReq())
+return NS_ERROR_CORRUPTED_CONTENT;
+}
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel <byte-range>
+//-----------------------------------------------------------------------------
+bool
+nsHttpChannel::IsResumable(int64_t partialLen, int64_t contentLength,
+bool ignoreMissingPartialLen) const
+{
+bool hasContentEncoding =
+mCachedResponseHead->PeekHeader(nsHttp::Content_Encoding)
+!= nullptr;
+return (partialLen < contentLength) &&
+(partialLen > 0 || ignoreMissingPartialLen) &&
+!hasContentEncoding &&
+mCachedResponseHead->IsResumable() &&
+!mCustomConditionalRequest &&
+!mCachedResponseHead->NoStore();
+}
+nsresult
+nsHttpChannel::MaybeSetupByteRangeRequest(int64_t partialLen, int64_t contentLength)
+{
+// Be pesimistic
+mIsPartialRequest = false;
+if (!IsResumable(partialLen, contentLength))
+return NS_ERROR_NOT_RESUMABLE;
+// looks like a partial entry we can reuse; add If-Range
+// and Range headers.
+nsresult rv = SetupByteRangeRequest(partialLen);
+if (NS_FAILED(rv)) {
+// Make the request unconditional again.
+mRequestHead.ClearHeader(nsHttp::Range);
+mRequestHead.ClearHeader(nsHttp::If_Range);
+}
+return rv;
+}
+nsresult
+nsHttpChannel::SetupByteRangeRequest(int64_t partialLen)
+{
+// cached content has been found to be partial, add necessary request
+// headers to complete cache entry.
+// use strongest validator available...
+const char *val = mCachedResponseHead->PeekHeader(nsHttp::ETag);
+if (!val)
+val = mCachedResponseHead->PeekHeader(nsHttp::Last_Modified);
+if (!val) {
+// if we hit this code it means mCachedResponseHead->IsResumable() is
+// either broken or not being called.
+NS_NOTREACHED("no cache validator");
+mIsPartialRequest = false;
+return NS_ERROR_FAILURE;
+}
+char buf[64];
+PR_snprintf(buf, sizeof(buf), "bytes=%lld-", partialLen);
+mRequestHead.SetHeader(nsHttp::Range, nsDependentCString(buf));
+mRequestHead.SetHeader(nsHttp::If_Range, nsDependentCString(val));
+mIsPartialRequest = true;
+return NS_OK;
+}
+nsresult
+nsHttpChannel::ProcessPartialContent()
+{
+// ok, we've just received a 206
+//
+// we need to stream whatever data is in the cache out first, and then
+// pick up whatever data is on the wire, writing it into the cache.
+LOG(("nsHttpChannel::ProcessPartialContent [this=%p]\n", this));
+NS_ENSURE_TRUE(mCachedResponseHead, NS_ERROR_NOT_INITIALIZED);
+NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_INITIALIZED);
+// Make sure to clear bogus content-encodings before looking at the header
+ClearBogusContentEncodingIfNeeded();
+// Check if the content-encoding we now got is different from the one we
+// got before
+if (PL_strcasecmp(mResponseHead->PeekHeader(nsHttp::Content_Encoding),
+mCachedResponseHead->PeekHeader(nsHttp::Content_Encoding))
+!= 0) {
+Cancel(NS_ERROR_INVALID_CONTENT_ENCODING);
+return CallOnStartRequest();
+}
+nsresult rv;
+int64_t cachedContentLength = mCachedResponseHead->ContentLength();
+int64_t entitySize = mResponseHead->TotalEntitySize();
+LOG(("nsHttpChannel::ProcessPartialContent [this=%p trans=%p] "
+"original content-length %lld, entity-size %lld, content-range %s\n",
+this, mTransaction.get(), cachedContentLength, entitySize,
+mResponseHead->PeekHeader(nsHttp::Content_Range)));
+if ((entitySize >= 0) && (cachedContentLength >= 0) &&
+(entitySize != cachedContentLength)) {
+LOG(("nsHttpChannel::ProcessPartialContent [this=%p] "
+"206 has different total entity size than the content length "
+"of the original partially cached entity.\n", this));
+mCacheEntry->AsyncDoom(nullptr);
+Cancel(NS_ERROR_CORRUPTED_CONTENT);
+return CallOnStartRequest();
+}
+if (mConcurentCacheAccess) {
+// We started to read cached data sooner than its write has been done.
+// But the concurrent write has not finished completely, so we had to
+// do a range request.  Now let the content coming from the network
+// be presented to consumers and also stored to the cache entry.
+rv = InstallCacheListener(mLogicalOffset);
+if (NS_FAILED(rv)) return rv;
+if (mOfflineCacheEntry) {
+rv = InstallOfflineCacheListener(mLogicalOffset);
+if (NS_FAILED(rv)) return rv;
+}
+// merge any new headers with the cached response headers
+rv = mCachedResponseHead->UpdateHeaders(mResponseHead->Headers());
+if (NS_FAILED(rv)) return rv;
+// update the cached response head
+nsAutoCString head;
+mCachedResponseHead->Flatten(head, true);
+rv = mCacheEntry->SetMetaDataElement("response-head", head.get());
+if (NS_FAILED(rv)) return rv;
+UpdateInhibitPersistentCachingFlag();
+rv = UpdateExpirationTime();
+if (NS_FAILED(rv)) return rv;
+mCachedContentIsPartial = false;
+// notify observers interested in looking at a response that has been
+// merged with any cached headers (http-on-examine-merged-response).
+gHttpHandler->OnExamineMergedResponse(this);
+}
+else {
+// suspend the current transaction
+rv = mTransactionPump->Suspend();
+if (NS_FAILED(rv)) return rv;
+// merge any new headers with the cached response headers
+rv = mCachedResponseHead->UpdateHeaders(mResponseHead->Headers());
+if (NS_FAILED(rv)) return rv;
+// update the cached response head
+nsAutoCString head;
+mCachedResponseHead->Flatten(head, true);
+rv = mCacheEntry->SetMetaDataElement("response-head", head.get());
+if (NS_FAILED(rv)) return rv;
+// make the cached response be the current response
+mResponseHead = mCachedResponseHead;
+UpdateInhibitPersistentCachingFlag();
+rv = UpdateExpirationTime();
+if (NS_FAILED(rv)) return rv;
+// notify observers interested in looking at a response that has been
+// merged with any cached headers (http-on-examine-merged-response).
+gHttpHandler->OnExamineMergedResponse(this);
+// the cached content is valid, although incomplete.
+mCachedContentIsValid = true;
+rv = ReadFromCache(false);
+}
+return rv;
+}
+nsresult
+nsHttpChannel::OnDoneReadingPartialCacheEntry(bool *streamDone)
+{
+nsresult rv;
+LOG(("nsHttpChannel::OnDoneReadingPartialCacheEntry [this=%p]", this));
+// by default, assume we would have streamed all data or failed...
+*streamDone = true;
+// setup cache listener to append to cache entry
+int64_t size;
+rv = mCacheEntry->GetDataSize(&size);
+if (NS_FAILED(rv)) return rv;
+rv = InstallCacheListener(size);
+if (NS_FAILED(rv)) return rv;
+// Entry is valid, do it now, after the output stream has been opened,
+// otherwise when done earlier, pending readers would consider the cache
+// entry still as partial (CacheEntry::GetDataSize would return the partial
+// data size) and consumers would do the conditional request again.
+rv = mCacheEntry->SetValid();
+if (NS_FAILED(rv)) return rv;
+// need to track the logical offset of the data being sent to our listener
+mLogicalOffset = size;
+// we're now completing the cached content, so we can clear this flag.
+// this puts us in the state of a regular download.
+mCachedContentIsPartial = false;
+// resume the transaction if it exists, otherwise the pipe contained the
+// remaining part of the document and we've now streamed all of the data.
+if (mTransactionPump) {
+rv = mTransactionPump->Resume();
+if (NS_SUCCEEDED(rv))
+*streamDone = false;
+}
+else
+NS_NOTREACHED("no transaction");
+return rv;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel <cache>
+//-----------------------------------------------------------------------------
+nsresult
+nsHttpChannel::ProcessNotModified()
+{
+nsresult rv;
+LOG(("nsHttpChannel::ProcessNotModified [this=%p]\n", this));
+if (mCustomConditionalRequest) {
+LOG(("Bypassing ProcessNotModified due to custom conditional headers"));
+return NS_ERROR_FAILURE;
+}
+if (!mDidReval) {
+LOG(("Server returned a 304 response even though we did not send a "
+"conditional request"));
+return NS_ERROR_FAILURE;
+}
+MOZ_ASSERT(mCachedResponseHead);
+MOZ_ASSERT(mCacheEntry);
+NS_ENSURE_TRUE(mCachedResponseHead && mCacheEntry, NS_ERROR_UNEXPECTED);
+// If the 304 response contains a Last-Modified different than the
+// one in our cache that is pretty suspicious and is, in at least the
+// case of bug 716840, a sign of the server having previously corrupted
+// our cache with a bad response. Take the minor step here of just dooming
+// that cache entry so there is a fighting chance of getting things on the
+// right track as well as disabling pipelining for that host.
+nsAutoCString lastModifiedCached;
+nsAutoCString lastModified304;
+rv = mCachedResponseHead->GetHeader(nsHttp::Last_Modified,
+lastModifiedCached);
+if (NS_SUCCEEDED(rv)) {
+rv = mResponseHead->GetHeader(nsHttp::Last_Modified,
+lastModified304);
+}
+if (NS_SUCCEEDED(rv) && !lastModified304.Equals(lastModifiedCached)) {
+LOG(("Cache Entry and 304 Last-Modified Headers Do Not Match "
+"[%s] and [%s]\n",
+lastModifiedCached.get(), lastModified304.get()));
+mCacheEntry->AsyncDoom(nullptr);
+if (mConnectionInfo)
+gHttpHandler->ConnMgr()->
+PipelineFeedbackInfo(mConnectionInfo,
+nsHttpConnectionMgr::RedCorruptedContent,
+nullptr, 0);
+Telemetry::Accumulate(Telemetry::CACHE_LM_INCONSISTENT, true);
+}
+// merge any new headers with the cached response headers
+rv = mCachedResponseHead->UpdateHeaders(mResponseHead->Headers());
+if (NS_FAILED(rv)) return rv;
+// update the cached response head
+nsAutoCString head;
+mCachedResponseHead->Flatten(head, true);
+rv = mCacheEntry->SetMetaDataElement("response-head", head.get());
+if (NS_FAILED(rv)) return rv;
+// make the cached response be the current response
+mResponseHead = mCachedResponseHead;
+UpdateInhibitPersistentCachingFlag();
+rv = UpdateExpirationTime();
+if (NS_FAILED(rv)) return rv;
+rv = AddCacheEntryHeaders(mCacheEntry);
+if (NS_FAILED(rv)) return rv;
+// notify observers interested in looking at a reponse that has been
+// merged with any cached headers
+gHttpHandler->OnExamineMergedResponse(this);
+mCachedContentIsValid = true;
+// Tell other consumers the entry is OK to use
+rv = mCacheEntry->SetValid();
+if (NS_FAILED(rv)) return rv;
+rv = ReadFromCache(false);
+if (NS_FAILED(rv)) return rv;
+mTransactionReplaced = true;
+return NS_OK;
+}
+nsresult
+nsHttpChannel::ProcessFallback(bool *waitingForRedirectCallback)
+{
+LOG(("nsHttpChannel::ProcessFallback [this=%p]\n", this));
+nsresult rv;
+*waitingForRedirectCallback = false;
+mFallingBack = false;
+// At this point a load has failed (either due to network problems
+// or an error returned on the server).  Perform an application
+// cache fallback if we have a URI to fall back to.
+if (!mApplicationCache || mFallbackKey.IsEmpty() || mFallbackChannel) {
+LOG(("  choosing not to fallback [%p,%s,%d]",
+mApplicationCache.get(), mFallbackKey.get(), mFallbackChannel));
+return NS_OK;
+}
+// Make sure the fallback entry hasn't been marked as a foreign
+// entry.
+uint32_t fallbackEntryType;
+rv = mApplicationCache->GetTypes(mFallbackKey, &fallbackEntryType);
+NS_ENSURE_SUCCESS(rv, rv);
+if (fallbackEntryType & nsIApplicationCache::ITEM_FOREIGN) {
+// This cache points to a fallback that refers to a different
+// manifest.  Refuse to fall back.
+return NS_OK;
+}
+MOZ_ASSERT(fallbackEntryType & nsIApplicationCache::ITEM_FALLBACK,
+"Fallback entry not marked correctly!");
+// Kill any offline cache entry, and disable offline caching for the
+// fallback.
+if (mOfflineCacheEntry) {
+mOfflineCacheEntry->AsyncDoom(nullptr);
+mOfflineCacheEntry = nullptr;
+}
+mApplicationCacheForWrite = nullptr;
+mOfflineCacheEntry = nullptr;
+// Close the current cache entry.
+CloseCacheEntry(true);
+// Create a new channel to load the fallback entry.
+nsRefPtr<nsIChannel> newChannel;
+rv = gHttpHandler->NewChannel(mURI, getter_AddRefs(newChannel));
+NS_ENSURE_SUCCESS(rv, rv);
+rv = SetupReplacementChannel(mURI, newChannel, true);
+NS_ENSURE_SUCCESS(rv, rv);
+// Make sure the new channel loads from the fallback key.
+nsCOMPtr<nsIHttpChannelInternal> httpInternal =
+do_QueryInterface(newChannel, &rv);
+NS_ENSURE_SUCCESS(rv, rv);
+rv = httpInternal->SetupFallbackChannel(mFallbackKey.get());
+NS_ENSURE_SUCCESS(rv, rv);
+// ... and fallbacks should only load from the cache.
+uint32_t newLoadFlags = mLoadFlags | LOAD_REPLACE | LOAD_ONLY_FROM_CACHE;
+rv = newChannel->SetLoadFlags(newLoadFlags);
+// Inform consumers about this fake redirect
+mRedirectChannel = newChannel;
+uint32_t redirectFlags = nsIChannelEventSink::REDIRECT_INTERNAL;
+PushRedirectAsyncFunc(&nsHttpChannel::ContinueProcessFallback);
+rv = gHttpHandler->AsyncOnChannelRedirect(this, newChannel, redirectFlags);
+if (NS_SUCCEEDED(rv))
+rv = WaitForRedirectCallback();
+if (NS_FAILED(rv)) {
+AutoRedirectVetoNotifier notifier(this);
+PopRedirectAsyncFunc(&nsHttpChannel::ContinueProcessFallback);
+return rv;
+}
+// Indicate we are now waiting for the asynchronous redirect callback
+// if all went OK.
+*waitingForRedirectCallback = true;
+return NS_OK;
+}
+nsresult
+nsHttpChannel::ContinueProcessFallback(nsresult rv)
+{
+AutoRedirectVetoNotifier notifier(this);
+if (NS_FAILED(rv))
+return rv;
+NS_PRECONDITION(mRedirectChannel, "No redirect channel?");
+// Make sure to do this _after_ calling OnChannelRedirect
+mRedirectChannel->SetOriginalURI(mOriginalURI);
+rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);
+if (NS_FAILED(rv))
+return rv;
+if (mLoadFlags & LOAD_INITIAL_DOCUMENT_URI) {
+Telemetry::Accumulate(Telemetry::HTTP_OFFLINE_CACHE_DOCUMENT_LOAD,
+true);
+}
+// close down this channel
+Cancel(NS_BINDING_REDIRECTED);
+notifier.RedirectSucceeded();
+ReleaseListeners();
+mFallingBack = true;
+return NS_OK;
+}
+// Determines if a request is a byte range request for a subrange,
+// i.e. is a byte range request, but not a 0- byte range request.
+static bool
+IsSubRangeRequest(nsHttpRequestHead &aRequestHead)
+{
+if (!aRequestHead.PeekHeader(nsHttp::Range))
+return false;
+nsAutoCString byteRange;
+aRequestHead.GetHeader(nsHttp::Range, byteRange);
+return !byteRange.EqualsLiteral("bytes=0-");
+}
+nsresult
+nsHttpChannel::OpenCacheEntry(bool usingSSL)
+{
+MOZ_EVENT_TRACER_EXEC(this, "net::http::OpenCacheEntry");
+// Handle correctly mCacheEntriesToWaitFor
+AutoCacheWaitFlags waitFlags(this);
+// Drop this flag here
+mConcurentCacheAccess = 0;
+nsresult rv;
+mLoadedFromApplicationCache = false;
+mHasQueryString = HasQueryString(mRequestHead.ParsedMethod(), mURI);
+LOG(("nsHttpChannel::OpenCacheEntry [this=%p]", this));
+// make sure we're not abusing this function
+NS_PRECONDITION(!mCacheEntry, "cache entry already open");
+nsAutoCString cacheKey;
+if (mRequestHead.IsPost()) {
+// If the post id is already set then this is an attempt to replay
+// a post transaction via the cache.  Otherwise, we need a unique
+// post id for this transaction.
+if (mPostID == 0)
+mPostID = gHttpHandler->GenerateUniqueID();
+}
+else if (!mRequestHead.IsGet() && !mRequestHead.IsHead()) {
+// don't use the cache for other types of requests
+return NS_OK;
+}
+if (mResuming) {
+// We don't support caching for requests initiated
+// via nsIResumableChannel.
+return NS_OK;
+}
+// Don't cache byte range requests which are subranges, only cache 0-
+// byte range requests.
+if (IsSubRangeRequest(mRequestHead))
+return NS_OK;
+// Pick up an application cache from the notification
+// callbacks if available
+if (!mApplicationCache && mInheritApplicationCache) {
+nsCOMPtr<nsIApplicationCacheContainer> appCacheContainer;
+GetCallback(appCacheContainer);
+if (appCacheContainer) {
+appCacheContainer->GetApplicationCache(getter_AddRefs(mApplicationCache));
+}
+}
+nsCOMPtr<nsICacheStorageService> cacheStorageService =
+do_GetService("@mozilla.org/netwerk/cache-storage-service;1", &rv);
+NS_ENSURE_SUCCESS(rv, rv);
+nsRefPtr<LoadContextInfo> info = GetLoadContextInfo(this);
+nsCOMPtr<nsICacheStorage> cacheStorage;
+nsCOMPtr<nsIURI> openURI;
+/* Obtain optional third party isolation domain */
+nsAutoCString cacheDomain;
+nsCOMPtr<nsIURI> firstPartyIsolationURI;
+nsCOMPtr<mozIThirdPartyUtil> thirdPartySvc
+= do_GetService(THIRDPARTYUTIL_CONTRACTID);
+rv = thirdPartySvc->GetFirstPartyIsolationURI(this, nullptr,
+getter_AddRefs(firstPartyIsolationURI));
+if (NS_SUCCEEDED(rv) && firstPartyIsolationURI) {
+thirdPartySvc->GetFirstPartyHostForIsolation(firstPartyIsolationURI,
+cacheDomain);
+}
+if (!mFallbackKey.IsEmpty() && mFallbackChannel) {
+// This is a fallback channel, open fallback URI instead
+rv = NS_NewURI(getter_AddRefs(openURI), mFallbackKey);
+NS_ENSURE_SUCCESS(rv, rv);
+}
+else {
+openURI = mURI;
+}
+uint32_t cacheEntryOpenFlags;
+bool offline = gIOService->IsOffline();
+if (offline || (mLoadFlags & INHIBIT_CACHING)) {
+if (BYPASS_LOCAL_CACHE(mLoadFlags) && !offline) {
+goto bypassCacheEntryOpen;
+}
+cacheEntryOpenFlags = nsICacheStorage::OPEN_READONLY;
+mCacheEntryIsReadOnly = true;
+}
+else if (BYPASS_LOCAL_CACHE(mLoadFlags) && !mApplicationCache) {
+cacheEntryOpenFlags = nsICacheStorage::OPEN_TRUNCATE;
+}
+else {
+cacheEntryOpenFlags = nsICacheStorage::OPEN_NORMALLY
+| nsICacheStorage::CHECK_MULTITHREADED;
+}
+if (mApplicationCache) {
+rv = cacheStorageService->AppCacheStorage(info,
+mApplicationCache,
+getter_AddRefs(cacheStorage));
+}
+else if (mLoadFlags & INHIBIT_PERSISTENT_CACHING) {
+rv = cacheStorageService->MemoryCacheStorage(info, // ? choose app cache as well...
+getter_AddRefs(cacheStorage));
+}
+else {
+rv = cacheStorageService->DiskCacheStorage(info,
+mChooseApplicationCache || (mLoadFlags & LOAD_CHECK_OFFLINE_CACHE),
+getter_AddRefs(cacheStorage));
+}
+NS_ENSURE_SUCCESS(rv, rv);
+// Don't consider mLoadUnblocked here, since it's not indication of a demand
+// to load prioritly. It's mostly used to load XHR requests, but those should
+// not be considered as influencing the page load performance.
+if (mLoadAsBlocking || (mLoadFlags & LOAD_INITIAL_DOCUMENT_URI))
+cacheEntryOpenFlags |= nsICacheStorage::OPEN_PRIORITY;
+// Only for backward compatibility with the old cache back end.
+// When removed, remove the flags and related code snippets.
+if (mLoadFlags & LOAD_BYPASS_LOCAL_CACHE_IF_BUSY)
+cacheEntryOpenFlags |= nsICacheStorage::OPEN_BYPASS_IF_BUSY;
+rv = cacheStorage->AsyncOpenURI(
+openURI, nsPrintfCString("%s@%d", cacheDomain.get(), mPostID),
+cacheEntryOpenFlags, this);
+NS_ENSURE_SUCCESS(rv, rv);
+waitFlags.Keep(WAIT_FOR_CACHE_ENTRY);
+bypassCacheEntryOpen:
+if (!mApplicationCacheForWrite)
+return NS_OK;
+// If there is an app cache to write to, open the entry right now in parallel.
+// make sure we're not abusing this function
+NS_PRECONDITION(!mOfflineCacheEntry, "cache entry already open");
+if (offline) {
+// only put things in the offline cache while online
+return NS_OK;
+}
+if (mLoadFlags & INHIBIT_CACHING) {
+// respect demand not to cache
+return NS_OK;
+}
+if (!mRequestHead.IsGet()) {
+// only cache complete documents offline
+return NS_OK;
+}
+rv = cacheStorageService->AppCacheStorage(info, mApplicationCacheForWrite,
+getter_AddRefs(cacheStorage));
+NS_ENSURE_SUCCESS(rv, rv);
+rv = cacheStorage->AsyncOpenURI(
+mURI, cacheDomain, nsICacheStorage::OPEN_TRUNCATE, this);
+NS_ENSURE_SUCCESS(rv, rv);
+waitFlags.Keep(WAIT_FOR_OFFLINE_CACHE_ENTRY);
+return NS_OK;
+}
+nsresult
+nsHttpChannel::CheckPartial(nsICacheEntry* aEntry, int64_t *aSize, int64_t *aContentLength)
+{
+nsresult rv;
+rv = aEntry->GetDataSize(aSize);
+if (NS_ERROR_IN_PROGRESS == rv) {
+*aSize = -1;
+rv = NS_OK;
+}
+NS_ENSURE_SUCCESS(rv, rv);
+nsHttpResponseHead* responseHead = mCachedResponseHead
+? mCachedResponseHead
+: mResponseHead;
+if (!responseHead)
+return NS_ERROR_UNEXPECTED;
+*aContentLength = responseHead->ContentLength();
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::OnCacheEntryCheck(nsICacheEntry* entry, nsIApplicationCache* appCache,
+uint32_t* aResult)
+{
+nsresult rv = NS_OK;
+LOG(("nsHttpChannel::OnCacheEntryCheck enter [channel=%p entry=%p]",
+this, entry));
+// Remember the request is a custom conditional request so that we can
+// process any 304 response correctly.
+mCustomConditionalRequest =
+mRequestHead.PeekHeader(nsHttp::If_Modified_Since) ||
+mRequestHead.PeekHeader(nsHttp::If_None_Match) ||
+mRequestHead.PeekHeader(nsHttp::If_Unmodified_Since) ||
+mRequestHead.PeekHeader(nsHttp::If_Match) ||
+mRequestHead.PeekHeader(nsHttp::If_Range);
+// Be pessimistic: assume the cache entry has no useful data.
+*aResult = ENTRY_WANTED;
+mCachedContentIsValid = false;
+nsXPIDLCString buf;
+// Get the method that was used to generate the cached response
+rv = entry->GetMetaDataElement("request-method", getter_Copies(buf));
+NS_ENSURE_SUCCESS(rv, rv);
+bool methodWasHead = buf.EqualsLiteral("HEAD");
+bool methodWasGet = buf.EqualsLiteral("GET");
+if (methodWasHead) {
+// The cached response does not contain an entity.  We can only reuse
+// the response if the current request is also HEAD.
+if (!mRequestHead.IsHead()) {
+return NS_OK;
+}
+}
+buf.Adopt(0);
+// We'll need this value in later computations...
+uint32_t lastModifiedTime;
+rv = entry->GetLastModified(&lastModifiedTime);
+NS_ENSURE_SUCCESS(rv, rv);
+// Determine if this is the first time that this cache entry
+// has been accessed during this session.
+bool fromPreviousSession =
+(gHttpHandler->SessionStartTime() > lastModifiedTime);
+// Get the cached HTTP response headers
+rv = entry->GetMetaDataElement("response-head", getter_Copies(buf));
+NS_ENSURE_SUCCESS(rv, rv);
+// Parse the cached HTTP response headers
+mCachedResponseHead = new nsHttpResponseHead();
+rv = mCachedResponseHead->Parse((char *) buf.get());
+NS_ENSURE_SUCCESS(rv, rv);
+buf.Adopt(0);
+bool isCachedRedirect = WillRedirect(mCachedResponseHead);
+// Do not return 304 responses from the cache, and also do not return
+// any other non-redirect 3xx responses from the cache (see bug 759043).
+NS_ENSURE_TRUE((mCachedResponseHead->Status() / 100 != 3) ||
+isCachedRedirect, NS_ERROR_ABORT);
+// Don't bother to validate items that are read-only,
+// unless they are read-only because of INHIBIT_CACHING or because
+// we're updating the offline cache.
+// Don't bother to validate if this is a fallback entry.
+if (!mApplicationCacheForWrite &&
+(appCache ||
+(mCacheEntryIsReadOnly && !(mLoadFlags & nsIRequest::INHIBIT_CACHING)) ||
+mFallbackChannel)) {
+rv = OpenCacheInputStream(entry, true);
+if (NS_SUCCEEDED(rv)) {
+mCachedContentIsValid = true;
+entry->MaybeMarkValid();
+}
+return rv;
+}
+bool wantCompleteEntry = false;
+if (!methodWasHead && !isCachedRedirect) {
+// If the cached content-length is set and it does not match the data
+// size of the cached content, then the cached response is partial...
+// either we need to issue a byte range request or we need to refetch
+// the entire document.
+//
+// We exclude redirects from this check because we (usually) strip the
+// entity when we store the cache entry, and even if we didn't, we
+// always ignore a cached redirect's entity anyway. See bug 759043.
+int64_t size, contentLength;
+rv = CheckPartial(entry, &size, &contentLength);
+NS_ENSURE_SUCCESS(rv,rv);
+if (size == int64_t(-1)) {
+LOG(("  write is in progress"));
+if (mLoadFlags & LOAD_BYPASS_LOCAL_CACHE_IF_BUSY) {
+LOG(("  not interested in the entry, "
+"LOAD_BYPASS_LOCAL_CACHE_IF_BUSY specified"));
+*aResult = ENTRY_NOT_WANTED;
+return NS_OK;
+}
+// Ignore !(size > 0) from the resumability condition
+if (!IsResumable(size, contentLength, true)) {
+LOG(("  wait for entry completion, "
+"response is not resumable"));
+wantCompleteEntry = true;
+}
+else {
+mConcurentCacheAccess = 1;
+}
+}
+else if (contentLength != int64_t(-1) && contentLength != size) {
+LOG(("Cached data size does not match the Content-Length header "
+"[content-length=%lld size=%lld]\n", contentLength, size));
+rv = MaybeSetupByteRangeRequest(size, contentLength);
+mCachedContentIsPartial = NS_SUCCEEDED(rv) && mIsPartialRequest;
+if (mCachedContentIsPartial) {
+rv = OpenCacheInputStream(entry, false);
+*aResult = ENTRY_NEEDS_REVALIDATION;
+}
+return rv;
+}
+}
+bool usingSSL = false;
+rv = mURI->SchemeIs("https", &usingSSL);
+NS_ENSURE_SUCCESS(rv,rv);
+bool doValidation = false;
+bool canAddImsHeader = true;
+// Cached entry is not the entity we request (see bug #633743)
+if (ResponseWouldVary(entry)) {
+LOG(("Validating based on Vary headers returning TRUE\n"));
+canAddImsHeader = false;
+doValidation = true;
+}
+// If the LOAD_FROM_CACHE flag is set, any cached data can simply be used
+else if (mLoadFlags & nsIRequest::LOAD_FROM_CACHE) {
+LOG(("NOT validating based on LOAD_FROM_CACHE load flag\n"));
+doValidation = false;
+}
+// If the VALIDATE_ALWAYS flag is set, any cached data won't be used until
+// it's revalidated with the server.
+else if (mLoadFlags & nsIRequest::VALIDATE_ALWAYS) {
+LOG(("Validating based on VALIDATE_ALWAYS load flag\n"));
+doValidation = true;
+}
+// Even if the VALIDATE_NEVER flag is set, there are still some cases in
+// which we must validate the cached response with the server.
+else if (mLoadFlags & nsIRequest::VALIDATE_NEVER) {
+LOG(("VALIDATE_NEVER set\n"));
+// if no-store or if no-cache and ssl, validate cached response (see
+// bug 112564 for an explanation of this logic)
+if (mCachedResponseHead->NoStore() ||
+(mCachedResponseHead->NoCache() && usingSSL)) {
+LOG(("Validating based on (no-store || (no-cache && ssl)) logic\n"));
+doValidation = true;
+}
+else {
+LOG(("NOT validating based on VALIDATE_NEVER load flag\n"));
+doValidation = false;
+}
+}
+// check if validation is strictly required...
+else if (mCachedResponseHead->MustValidate()) {
+LOG(("Validating based on MustValidate() returning TRUE\n"));
+doValidation = true;
+}
+else if (MustValidateBasedOnQueryUrl()) {
+LOG(("Validating based on RFC 2616 section 13.9 "
+"(query-url w/o explicit expiration-time)\n"));
+doValidation = true;
+}
+// Check if the cache entry has expired...
+else {
+uint32_t time = 0; // a temporary variable for storing time values...
+rv = entry->GetExpirationTime(&time);
+NS_ENSURE_SUCCESS(rv, rv);
+LOG(("  NowInSeconds()=%u, time=%u", NowInSeconds(), time));
+if (NowInSeconds() <= time)
+doValidation = false;
+else if (mCachedResponseHead->MustValidateIfExpired())
+doValidation = true;
+else if (mLoadFlags & nsIRequest::VALIDATE_ONCE_PER_SESSION) {
+// If the cached response does not include expiration infor-
+// mation, then we must validate the response, despite whether
+// or not this is the first access this session.  This behavior
+// is consistent with existing browsers and is generally expected
+// by web authors.
+rv = mCachedResponseHead->ComputeFreshnessLifetime(&time);
+NS_ENSURE_SUCCESS(rv, rv);
+if (time == 0)
+doValidation = true;
+else
+doValidation = fromPreviousSession;
+}
+else
+doValidation = true;
+LOG(("%salidating based on expiration time\n", doValidation ? "V" : "Not v"));
+}
+if (!doValidation && mRequestHead.PeekHeader(nsHttp::If_Match) &&
+(methodWasGet || methodWasHead)) {
+const char *requestedETag, *cachedETag;
+cachedETag = mCachedResponseHead->PeekHeader(nsHttp::ETag);
+requestedETag = mRequestHead.PeekHeader(nsHttp::If_Match);
+if (cachedETag && (!strncmp(cachedETag, "W/", 2) ||
+strcmp(requestedETag, cachedETag))) {
+// User has defined If-Match header, if the cached entry is not
+// matching the provided header value or the cached ETag is weak,
+// force validation.
+doValidation = true;
+}
+}
+if (!doValidation) {
+//
+// Check the authorization headers used to generate the cache entry.
+// We must validate the cache entry if:
+//
+// 1) the cache entry was generated prior to this session w/
+//    credentials (see bug 103402).
+// 2) the cache entry was generated w/o credentials, but would now
+//    require credentials (see bug 96705).
+//
+// NOTE: this does not apply to proxy authentication.
+//
+entry->GetMetaDataElement("auth", getter_Copies(buf));
+doValidation =
+(fromPreviousSession && !buf.IsEmpty()) ||
+(buf.IsEmpty() && mRequestHead.PeekHeader(nsHttp::Authorization));
+}
+// Bug #561276: We maintain a chain of cache-keys which returns cached
+// 3xx-responses (redirects) in order to detect cycles. If a cycle is
+// found, ignore the cached response and hit the net. Otherwise, use
+// the cached response and add the cache-key to the chain. Note that
+// a limited number of redirects (cached or not) is allowed and is
+// enforced independently of this mechanism
+if (!doValidation && isCachedRedirect) {
+nsAutoCString cacheKey;
+GenerateCacheKey(mPostID, cacheKey);
+if (!mRedirectedCachekeys)
+mRedirectedCachekeys = new nsTArray<nsCString>();
+else if (mRedirectedCachekeys->Contains(cacheKey))
+doValidation = true;
+LOG(("Redirection-chain %s key %s\n",
+doValidation ? "contains" : "does not contain", cacheKey.get()));
+// Append cacheKey if not in the chain already
+if (!doValidation)
+mRedirectedCachekeys->AppendElement(cacheKey);
+}
+mCachedContentIsValid = !doValidation;
+if (doValidation) {
+//
+// now, we are definitely going to issue a HTTP request to the server.
+// make it conditional if possible.
+//
+// do not attempt to validate no-store content, since servers will not
+// expect it to be cached.  (we only keep it in our cache for the
+// purposes of back/forward, etc.)
+//
+// the request method MUST be either GET or HEAD (see bug 175641).
+//
+// do not override conditional headers when consumer has defined its own
+if (!mCachedResponseHead->NoStore() &&
+(mRequestHead.IsGet() || mRequestHead.IsHead()) &&
+!mCustomConditionalRequest) {
+if (mConcurentCacheAccess) {
+// In case of concurrent read and also validation request we
+// must wait for the current writer to close the output stream
+// first.  Otherwise, when the writer's job would have been interrupted
+// before all the data were downloaded, we'd have to do a range request
+// which would be a second request in line during this channel's
+// life-time.  nsHttpChannel is not designed to do that, so rather
+// turn off concurrent read and wait for entry's completion.
+// Then only re-validation or range-re-validation request will go out.
+mConcurentCacheAccess = 0;
+// This will cause that OnCacheEntryCheck is called again with the same
+// entry after the writer is done.
+wantCompleteEntry = true;
+} else {
+const char *val;
+// Add If-Modified-Since header if a Last-Modified was given
+// and we are allowed to do this (see bugs 510359 and 269303)
+if (canAddImsHeader) {
+val = mCachedResponseHead->PeekHeader(nsHttp::Last_Modified);
+if (val)
+mRequestHead.SetHeader(nsHttp::If_Modified_Since,
+nsDependentCString(val));
+}
+// Add If-None-Match header if an ETag was given in the response
+val = mCachedResponseHead->PeekHeader(nsHttp::ETag);
+if (val)
+mRequestHead.SetHeader(nsHttp::If_None_Match,
+nsDependentCString(val));
+mDidReval = true;
+}
+}
+}
+if (mCachedContentIsValid || mDidReval) {
+rv = OpenCacheInputStream(entry, mCachedContentIsValid);
+if (NS_FAILED(rv)) {
+// If we can't get the entity then we have to act as though we
+// don't have the cache entry.
+if (mDidReval) {
+// Make the request unconditional again.
+mRequestHead.ClearHeader(nsHttp::If_Modified_Since);
+mRequestHead.ClearHeader(nsHttp::If_None_Match);
+mRequestHead.ClearHeader(nsHttp::ETag);
+mDidReval = false;
+}
+mCachedContentIsValid = false;
+}
+}
+if (mDidReval)
+*aResult = ENTRY_NEEDS_REVALIDATION;
+else if (wantCompleteEntry)
+*aResult = RECHECK_AFTER_WRITE_FINISHED;
+else
+*aResult = ENTRY_WANTED;
+if (mCachedContentIsValid) {
+entry->MaybeMarkValid();
+}
+LOG(("nsHTTPChannel::OnCacheEntryCheck exit [this=%p doValidation=%d result=%d]\n",
+this, doValidation, *aResult));
+return rv;
+}
+NS_IMETHODIMP
+nsHttpChannel::OnCacheEntryAvailable(nsICacheEntry *entry,
+bool aNew,
+nsIApplicationCache* aAppCache,
+nsresult status)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsresult rv;
+LOG(("nsHttpChannel::OnCacheEntryAvailable [this=%p entry=%p "
+"new=%d appcache=%p status=%x]\n", this, entry, aNew, aAppCache, status));
+// if the channel's already fired onStopRequest, then we should ignore
+// this event.
+if (!mIsPending) {
+mCacheInputStream.CloseAndRelease();
+return NS_OK;
+}
+rv = OnCacheEntryAvailableInternal(entry, aNew, aAppCache, status);
+if (NS_FAILED(rv)) {
+CloseCacheEntry(true);
+AsyncAbort(rv);
+}
+return NS_OK;
+}
+nsresult
+nsHttpChannel::OnCacheEntryAvailableInternal(nsICacheEntry *entry,
+bool aNew,
+nsIApplicationCache* aAppCache,
+nsresult status)
+{
+nsresult rv;
+if (mCanceled) {
+LOG(("channel was canceled [this=%p status=%x]\n", this, mStatus));
+return mStatus;
+}
+if (aAppCache) {
+if (mApplicationCache == aAppCache && !mCacheEntry) {
+rv = OnOfflineCacheEntryAvailable(entry, aNew, aAppCache, status);
+}
+else if (mApplicationCacheForWrite == aAppCache && aNew && !mOfflineCacheEntry) {
+rv = OnOfflineCacheEntryForWritingAvailable(entry, aAppCache, status);
+}
+else {
+rv = OnOfflineCacheEntryAvailable(entry, aNew, aAppCache, status);
+}
+}
+else {
+rv = OnNormalCacheEntryAvailable(entry, aNew, status);
+}
+if (NS_FAILED(rv) && (mLoadFlags & LOAD_ONLY_FROM_CACHE)) {
+// If we have a fallback URI (and we're not already
+// falling back), process the fallback asynchronously.
+if (!mFallbackChannel && !mFallbackKey.IsEmpty()) {
+return AsyncCall(&nsHttpChannel::HandleAsyncFallback);
+}
+return NS_ERROR_DOCUMENT_NOT_CACHED;
+}
+if (NS_FAILED(rv))
+return rv;
+// We may be waiting for more callbacks...
+if (mCacheEntriesToWaitFor)
+return NS_OK;
+return ContinueConnect();
+}
+nsresult
+nsHttpChannel::OnNormalCacheEntryAvailable(nsICacheEntry *aEntry,
+bool aNew,
+nsresult aEntryStatus)
+{
+mCacheEntriesToWaitFor &= ~WAIT_FOR_CACHE_ENTRY;
+if (NS_FAILED(aEntryStatus) || aNew) {
+// Make sure this flag is dropped.  It may happen the entry is doomed
+// between OnCacheEntryCheck and OnCacheEntryAvailable.
+mCachedContentIsValid = false;
+if (mLoadFlags & LOAD_ONLY_FROM_CACHE) {
+// if this channel is only allowed to pull from the cache, then
+// we must fail if we were unable to open a cache entry for read.
+return NS_ERROR_DOCUMENT_NOT_CACHED;
+}
+}
+if (NS_SUCCEEDED(aEntryStatus)) {
+mCacheEntry = aEntry;
+mCacheEntryIsWriteOnly = aNew;
+if (mLoadFlags & LOAD_INITIAL_DOCUMENT_URI) {
+Telemetry::Accumulate(Telemetry::HTTP_OFFLINE_CACHE_DOCUMENT_LOAD,
+false);
+}
+}
+return NS_OK;
+}
+nsresult
+nsHttpChannel::OnOfflineCacheEntryAvailable(nsICacheEntry *aEntry,
+bool aNew,
+nsIApplicationCache* aAppCache,
+nsresult aEntryStatus)
+{
+MOZ_ASSERT(!mApplicationCache || aAppCache == mApplicationCache);
+MOZ_ASSERT(!aNew || !aEntry || mApplicationCacheForWrite);
+mCacheEntriesToWaitFor &= ~WAIT_FOR_CACHE_ENTRY;
+nsresult rv;
+if (!mApplicationCache)
+mApplicationCache = aAppCache;
+if (NS_SUCCEEDED(aEntryStatus)) {
+// We successfully opened an offline cache session and the entry,
+// so indicate we will load from the offline cache.
+mLoadedFromApplicationCache = true;
+mCacheEntryIsReadOnly = true;
+mCacheEntry = aEntry;
+mCacheEntryIsWriteOnly = false;
+if (mLoadFlags & LOAD_INITIAL_DOCUMENT_URI && !mApplicationCacheForWrite) {
+Telemetry::Accumulate(Telemetry::HTTP_OFFLINE_CACHE_DOCUMENT_LOAD,
+true);
+}
+return NS_OK;
+}
+if (!mApplicationCacheForWrite && !mFallbackChannel) {
+// Check for namespace match.
+nsCOMPtr<nsIApplicationCacheNamespace> namespaceEntry;
+rv = mApplicationCache->GetMatchingNamespace(mSpec,
+getter_AddRefs(namespaceEntry));
+NS_ENSURE_SUCCESS(rv, rv);
+uint32_t namespaceType = 0;
+if (!namespaceEntry ||
+NS_FAILED(namespaceEntry->GetItemType(&namespaceType)) ||
+(namespaceType &
+(nsIApplicationCacheNamespace::NAMESPACE_FALLBACK |
+nsIApplicationCacheNamespace::NAMESPACE_BYPASS)) == 0) {
+// When loading from an application cache, only items
+// on the whitelist or matching a
+// fallback namespace should hit the network...
+mLoadFlags |= LOAD_ONLY_FROM_CACHE;
+// ... and if there were an application cache entry,
+// we would have found it earlier.
+return NS_ERROR_CACHE_KEY_NOT_FOUND;
+}
+if (namespaceType &
+nsIApplicationCacheNamespace::NAMESPACE_FALLBACK) {
+rv = namespaceEntry->GetData(mFallbackKey);
+NS_ENSURE_SUCCESS(rv, rv);
+}
+}
+return NS_OK;
+}
+nsresult
+nsHttpChannel::OnOfflineCacheEntryForWritingAvailable(nsICacheEntry *aEntry,
+nsIApplicationCache* aAppCache,
+nsresult aEntryStatus)
+{
+MOZ_ASSERT(mApplicationCacheForWrite && aAppCache == mApplicationCacheForWrite);
+mCacheEntriesToWaitFor &= ~WAIT_FOR_OFFLINE_CACHE_ENTRY;
+if (NS_SUCCEEDED(aEntryStatus)) {
+mOfflineCacheEntry = aEntry;
+if (NS_FAILED(aEntry->GetLastModified(&mOfflineCacheLastModifiedTime))) {
+mOfflineCacheLastModifiedTime = 0;
+}
+}
+return aEntryStatus;
+}
+// Generates the proper cache-key for this instance of nsHttpChannel
+nsresult
+nsHttpChannel::GenerateCacheKey(uint32_t postID, nsACString &cacheKey)
+{
+AssembleCacheKey(mFallbackChannel ? mFallbackKey.get() : mSpec.get(),
+postID, cacheKey);
+return NS_OK;
+}
+// Assembles a cache-key from the given pieces of information and |mLoadFlags|
+void
+nsHttpChannel::AssembleCacheKey(const char *spec, uint32_t postID,
+nsACString &cacheKey)
+{
+cacheKey.Truncate();
+if (mLoadFlags & LOAD_ANONYMOUS) {
+cacheKey.AssignLiteral("anon&");
+}
+if (postID) {
+char buf[32];
+PR_snprintf(buf, sizeof(buf), "id=%x&", postID);
+cacheKey.Append(buf);
+}
+if (strlen(mCacheDomain.get()) > 0) {
+cacheKey.AppendLiteral("domain=");
+cacheKey.Append(mCacheDomain.get());
+cacheKey.AppendLiteral("&");
+}
+if (!cacheKey.IsEmpty()) {
+cacheKey.AppendLiteral("uri=");
+}
+// Strip any trailing #ref from the URL before using it as the key
+const char *p = strchr(spec, '#');
+if (p)
+cacheKey.Append(spec, p - spec);
+else
+cacheKey.Append(spec);
+}
+// UpdateExpirationTime is called when a new response comes in from the server.
+// It updates the stored response-time and sets the expiration time on the
+// cache entry.
+//
+// From section 13.2.4 of RFC2616, we compute expiration time as follows:
+//
+//    timeRemaining = freshnessLifetime - currentAge
+//    expirationTime = now + timeRemaining
+//
+nsresult
+nsHttpChannel::UpdateExpirationTime()
+{
+NS_ENSURE_TRUE(mResponseHead, NS_ERROR_FAILURE);
+nsresult rv;
+uint32_t expirationTime = 0;
+if (!mResponseHead->MustValidate()) {
+uint32_t freshnessLifetime = 0;
+rv = mResponseHead->ComputeFreshnessLifetime(&freshnessLifetime);
+if (NS_FAILED(rv)) return rv;
+if (freshnessLifetime > 0) {
+uint32_t now = NowInSeconds(), currentAge = 0;
+rv = mResponseHead->ComputeCurrentAge(now, mRequestTime, &currentAge);
+if (NS_FAILED(rv)) return rv;
+LOG(("freshnessLifetime = %u, currentAge = %u\n",
+freshnessLifetime, currentAge));
+if (freshnessLifetime > currentAge) {
+uint32_t timeRemaining = freshnessLifetime - currentAge;
+// be careful... now + timeRemaining may overflow
+if (now + timeRemaining < now)
+expirationTime = uint32_t(-1);
+else
+expirationTime = now + timeRemaining;
+}
+else
+expirationTime = now;
+}
+}
+rv = mCacheEntry->SetExpirationTime(expirationTime);
+NS_ENSURE_SUCCESS(rv, rv);
+if (mOfflineCacheEntry) {
+rv = mOfflineCacheEntry->SetExpirationTime(expirationTime);
+NS_ENSURE_SUCCESS(rv, rv);
+}
+return NS_OK;
+}
+/*static*/ inline bool
+nsHttpChannel::HasQueryString(nsHttpRequestHead::ParsedMethodType method, nsIURI * uri)
+{
+// Must be called on the main thread because nsIURI does not implement
+// thread-safe QueryInterface.
+MOZ_ASSERT(NS_IsMainThread());
+if (method != nsHttpRequestHead::kMethod_Get &&
+method != nsHttpRequestHead::kMethod_Head)
+return false;
+nsAutoCString query;
+nsCOMPtr<nsIURL> url = do_QueryInterface(uri);
+nsresult rv = url->GetQuery(query);
+return NS_SUCCEEDED(rv) && !query.IsEmpty();
+}
+bool
+nsHttpChannel::MustValidateBasedOnQueryUrl() const
+{
+// RFC 2616, section 13.9 states that GET-requests with a query-url
+// MUST NOT be treated as fresh unless the server explicitly provides
+// an expiration-time in the response. See bug #468594
+// Section 13.2.1 (6th paragraph) defines "explicit expiration time"
+if (mHasQueryString)
+{
+uint32_t tmp; // we don't need the value, just whether it's set
+nsresult rv = mCachedResponseHead->GetExpiresValue(&tmp);
+if (NS_FAILED(rv)) {
+rv = mCachedResponseHead->GetMaxAgeValue(&tmp);
+if (NS_FAILED(rv)) {
+return true;
+}
+}
+}
+return false;
+}
+bool
+nsHttpChannel::ShouldUpdateOfflineCacheEntry()
+{
+if (!mApplicationCacheForWrite || !mOfflineCacheEntry) {
+return false;
+}
+// if we're updating the cache entry, update the offline cache entry too
+if (mCacheEntry && mCacheEntryIsWriteOnly) {
+return true;
+}
+// if there's nothing in the offline cache, add it
+if (mOfflineCacheEntry) {
+return true;
+}
+// if the document is newer than the offline entry, update it
+uint32_t docLastModifiedTime;
+nsresult rv = mResponseHead->GetLastModifiedValue(&docLastModifiedTime);
+if (NS_FAILED(rv)) {
+return true;
+}
+if (mOfflineCacheLastModifiedTime == 0) {
+return false;
+}
+if (docLastModifiedTime > mOfflineCacheLastModifiedTime) {
+return true;
+}
+return false;
+}
+nsresult
+nsHttpChannel::OpenCacheInputStream(nsICacheEntry* cacheEntry, bool startBuffering)
+{
+nsresult rv;
+bool usingSSL = false;
+rv = mURI->SchemeIs("https", &usingSSL);
+NS_ENSURE_SUCCESS(rv,rv);
+if (usingSSL) {
+rv = cacheEntry->GetSecurityInfo(
+getter_AddRefs(mCachedSecurityInfo));
+if (NS_FAILED(rv)) {
+LOG(("failed to parse security-info [channel=%p, entry=%p]",
+this, cacheEntry));
+NS_WARNING("failed to parse security-info");
+return rv;
+}
+// XXX: We should not be skilling this check in the offline cache
+// case, but we have to do so now to work around bug 794507.
+MOZ_ASSERT(mCachedSecurityInfo || mLoadedFromApplicationCache);
+if (!mCachedSecurityInfo && !mLoadedFromApplicationCache) {
+LOG(("mCacheEntry->GetSecurityInfo returned success but did not "
+"return the security info [channel=%p, entry=%p]",
+this, cacheEntry));
+return NS_ERROR_UNEXPECTED; // XXX error code
+}
+}
+// Keep the conditions below in sync with the conditions in ReadFromCache.
+rv = NS_OK;
+if (WillRedirect(mCachedResponseHead)) {
+// Do not even try to read the entity for a redirect because we do not
+// return an entity to the application when we process redirects.
+LOG(("Will skip read of cached redirect entity\n"));
+return NS_OK;
+}
+if ((mLoadFlags & nsICachingChannel::LOAD_ONLY_IF_MODIFIED) &&
+!mCachedContentIsPartial) {
+// For LOAD_ONLY_IF_MODIFIED, we usually don't have to deal with the
+// cached entity.
+if (!mApplicationCacheForWrite) {
+LOG(("Will skip read from cache based on LOAD_ONLY_IF_MODIFIED "
+"load flag\n"));
+return NS_OK;
+}
+// If offline caching has been requested and the offline cache needs
+// updating, we must complete the call even if the main cache entry
+// is up to date. We don't know yet for sure whether the offline
+// cache needs updating because at this point we haven't opened it
+// for writing yet, so we have to start reading the cached entity now
+// just in case.
+LOG(("May skip read from cache based on LOAD_ONLY_IF_MODIFIED "
+"load flag\n"));
+}
+// Open an input stream for the entity, so that the call to OpenInputStream
+// happens off the main thread.
+nsCOMPtr<nsIInputStream> stream;
+rv = cacheEntry->OpenInputStream(0, getter_AddRefs(stream));
+if (NS_FAILED(rv)) {
+LOG(("Failed to open cache input stream [channel=%p, "
+"mCacheEntry=%p]", this, cacheEntry));
+return rv;
+}
+if (startBuffering) {
+bool nonBlocking;
+rv = stream->IsNonBlocking(&nonBlocking);
+if (NS_SUCCEEDED(rv) && nonBlocking)
+startBuffering = false;
+}
+if (!startBuffering) {
+// Bypass wrapping the input stream for the new cache back-end since
+// nsIStreamTransportService expects a blocking stream.  Preloading of
+// the data must be done on the level of the cache backend, internally.
+//
+// We do not connect the stream to the stream transport service if we
+// have to validate the entry with the server. If we did, we would get
+// into a race condition between the stream transport service reading
+// the existing contents and the opening of the cache entry's output
+// stream to write the new contents in the case where we get a non-304
+// response.
+LOG(("Opened cache input stream without buffering [channel=%p, "
+"mCacheEntry=%p, stream=%p]", this,
+cacheEntry, stream.get()));
+mCacheInputStream.takeOver(stream);
+return rv;
+}
+// Have the stream transport service start reading the entity on one of its
+// background threads.
+nsCOMPtr<nsITransport> transport;
+nsCOMPtr<nsIInputStream> wrapper;
+nsCOMPtr<nsIStreamTransportService> sts =
+do_GetService(kStreamTransportServiceCID, &rv);
+if (NS_SUCCEEDED(rv)) {
+rv = sts->CreateInputTransport(stream, int64_t(-1), int64_t(-1),
+true, getter_AddRefs(transport));
+}
+if (NS_SUCCEEDED(rv)) {
+rv = transport->OpenInputStream(0, 0, 0, getter_AddRefs(wrapper));
+}
+if (NS_SUCCEEDED(rv)) {
+LOG(("Opened cache input stream [channel=%p, wrapper=%p, "
+"transport=%p, stream=%p]", this, wrapper.get(),
+transport.get(), stream.get()));
+} else {
+LOG(("Failed to open cache input stream [channel=%p, "
+"wrapper=%p, transport=%p, stream=%p]", this,
+wrapper.get(), transport.get(), stream.get()));
+stream->Close();
+return rv;
+}
+mCacheInputStream.takeOver(wrapper);
+return NS_OK;
+}
+// Actually process the cached response that we started to handle in CheckCache
+// and/or StartBufferingCachedEntity.
+nsresult
+nsHttpChannel::ReadFromCache(bool alreadyMarkedValid)
+{
+NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_FAILURE);
+NS_ENSURE_TRUE(mCachedContentIsValid, NS_ERROR_FAILURE);
+LOG(("nsHttpChannel::ReadFromCache [this=%p] "
+"Using cached copy of: %s\n", this, mSpec.get()));
+if (mCachedResponseHead)
+mResponseHead = mCachedResponseHead;
+UpdateInhibitPersistentCachingFlag();
+// if we don't already have security info, try to get it from the cache
+// entry. there are two cases to consider here: 1) we are just reading
+// from the cache, or 2) this may be due to a 304 not modified response,
+// in which case we could have security info from a socket transport.
+if (!mSecurityInfo)
+mSecurityInfo = mCachedSecurityInfo;
+if (!alreadyMarkedValid && !mCachedContentIsPartial) {
+// We validated the entry, and we have write access to the cache, so
+// mark the cache entry as valid in order to allow others access to
+// this cache entry.
+//
+// TODO: This should be done asynchronously so we don't take the cache
+// service lock on the main thread.
+mCacheEntry->MaybeMarkValid();
+}
+nsresult rv;
+// Keep the conditions below in sync with the conditions in
+// StartBufferingCachedEntity.
+if (WillRedirect(mResponseHead)) {
+// TODO: Bug 759040 - We should call HandleAsyncRedirect directly here,
+// to avoid event dispatching latency.
+MOZ_ASSERT(!mCacheInputStream);
+LOG(("Skipping skip read of cached redirect entity\n"));
+return AsyncCall(&nsHttpChannel::HandleAsyncRedirect);
+}
+if ((mLoadFlags & LOAD_ONLY_IF_MODIFIED) && !mCachedContentIsPartial) {
+if (!mApplicationCacheForWrite) {
+LOG(("Skipping read from cache based on LOAD_ONLY_IF_MODIFIED "
+"load flag\n"));
+MOZ_ASSERT(!mCacheInputStream);
+// TODO: Bug 759040 - We should call HandleAsyncNotModified directly
+// here, to avoid event dispatching latency.
+return AsyncCall(&nsHttpChannel::HandleAsyncNotModified);
+}
+if (!ShouldUpdateOfflineCacheEntry()) {
+LOG(("Skipping read from cache based on LOAD_ONLY_IF_MODIFIED "
+"load flag (mApplicationCacheForWrite not null case)\n"));
+mCacheInputStream.CloseAndRelease();
+// TODO: Bug 759040 - We should call HandleAsyncNotModified directly
+// here, to avoid event dispatching latency.
+return AsyncCall(&nsHttpChannel::HandleAsyncNotModified);
+}
+}
+MOZ_ASSERT(mCacheInputStream);
+if (!mCacheInputStream) {
+NS_ERROR("mCacheInputStream is null but we're expecting to "
+"be able to read from it.");
+return NS_ERROR_UNEXPECTED;
+}
+nsCOMPtr<nsIInputStream> inputStream = mCacheInputStream.forget();
+rv = nsInputStreamPump::Create(getter_AddRefs(mCachePump), inputStream,
+int64_t(-1), int64_t(-1), 0, 0, true);
+if (NS_FAILED(rv)) {
+inputStream->Close();
+return rv;
+}
+rv = mCachePump->AsyncRead(this, mListenerContext);
+if (NS_FAILED(rv)) return rv;
+if (mTimingEnabled)
+mCacheReadStart = TimeStamp::Now();
+uint32_t suspendCount = mSuspendCount;
+while (suspendCount--)
+mCachePump->Suspend();
+return NS_OK;
+}
+void
+nsHttpChannel::CloseCacheEntry(bool doomOnFailure)
+{
+mCacheInputStream.CloseAndRelease();
+if (!mCacheEntry)
+return;
+LOG(("nsHttpChannel::CloseCacheEntry [this=%p] mStatus=%x mCacheEntryIsWriteOnly=%x",
+this, mStatus, mCacheEntryIsWriteOnly));
+// If we have begun to create or replace a cache entry, and that cache
+// entry is not complete and not resumable, then it needs to be doomed.
+// Otherwise, CheckCache will make the mistake of thinking that the
+// partial cache entry is complete.
+bool doom = false;
+if (mInitedCacheEntry) {
+MOZ_ASSERT(mResponseHead, "oops");
+if (NS_FAILED(mStatus) && doomOnFailure &&
+mCacheEntryIsWriteOnly && !mResponseHead->IsResumable())
+doom = true;
+}
+else if (mCacheEntryIsWriteOnly)
+doom = true;
+if (doom) {
+LOG(("  dooming cache entry!!"));
+mCacheEntry->AsyncDoom(nullptr);
+}
+mCachedResponseHead = nullptr;
+mCachePump = nullptr;
+mCacheEntry = nullptr;
+mCacheEntryIsWriteOnly = false;
+mInitedCacheEntry = false;
+}
+void
+nsHttpChannel::CloseOfflineCacheEntry()
+{
+if (!mOfflineCacheEntry)
+return;
+LOG(("nsHttpChannel::CloseOfflineCacheEntry [this=%p]", this));
+if (NS_FAILED(mStatus)) {
+mOfflineCacheEntry->AsyncDoom(nullptr);
+}
+else {
+bool succeeded;
+if (NS_SUCCEEDED(GetRequestSucceeded(&succeeded)) && !succeeded)
+mOfflineCacheEntry->AsyncDoom(nullptr);
+}
+mOfflineCacheEntry = nullptr;
+}
+// Initialize the cache entry for writing.
+//  - finalize storage policy
+//  - store security info
+//  - update expiration time
+//  - store headers and other meta data
+nsresult
+nsHttpChannel::InitCacheEntry()
+{
+nsresult rv;
+NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_UNEXPECTED);
+// if only reading, nothing to be done here.
+if (mCacheEntryIsReadOnly)
+return NS_OK;
+// Don't cache the response again if already cached...
+if (mCachedContentIsValid)
+return NS_OK;
+LOG(("nsHttpChannel::InitCacheEntry [this=%p entry=%p]\n",
+this, mCacheEntry.get()));
+bool recreate = !mCacheEntryIsWriteOnly;
+bool dontPersist = mLoadFlags & INHIBIT_PERSISTENT_CACHING;
+if (!recreate && dontPersist) {
+// If the current entry is persistent but we inhibit peristence
+// then force recreation of the entry as memory/only.
+rv = mCacheEntry->GetPersistent(&recreate);
+if (NS_FAILED(rv))
+return rv;
+}
+if (recreate) {
+LOG(("  we have a ready entry, but reading it again from the server -> recreating cache entry\n"));
+nsCOMPtr<nsICacheEntry> currentEntry;
+currentEntry.swap(mCacheEntry);
+rv = currentEntry->Recreate(dontPersist, getter_AddRefs(mCacheEntry));
+if (NS_FAILED(rv)) {
+LOG(("  recreation failed, the response will not be cached"));
+return NS_OK;
+}
+mCacheEntryIsWriteOnly = true;
+}
+// Set the expiration time for this cache entry
+rv = UpdateExpirationTime();
+if (NS_FAILED(rv)) return rv;
+rv = AddCacheEntryHeaders(mCacheEntry);
+if (NS_FAILED(rv)) return rv;
+mInitedCacheEntry = true;
+// Don't perform the check when writing (doesn't make sense)
+mConcurentCacheAccess = 0;
+return NS_OK;
+}
+void
+nsHttpChannel::UpdateInhibitPersistentCachingFlag()
+{
+// The no-store directive within the 'Cache-Control:' header indicates
+// that we must not store the response in a persistent cache.
+if (mResponseHead->NoStore())
+mLoadFlags |= INHIBIT_PERSISTENT_CACHING;
+// Only cache SSL content on disk if the pref is set
+if (!gHttpHandler->IsPersistentHttpsCachingEnabled() &&
+mConnectionInfo->UsingSSL())
+mLoadFlags |= INHIBIT_PERSISTENT_CACHING;
+}
+nsresult
+nsHttpChannel::InitOfflineCacheEntry()
+{
+// This function can be called even when we fail to connect (bug 551990)
+if (!mOfflineCacheEntry) {
+return NS_OK;
+}
+if (!mResponseHead || mResponseHead->NoStore()) {
+if (mResponseHead && mResponseHead->NoStore()) {
+mOfflineCacheEntry->AsyncDoom(nullptr);
+}
+CloseOfflineCacheEntry();
+if (mResponseHead && mResponseHead->NoStore()) {
+return NS_ERROR_NOT_AVAILABLE;
+}
+return NS_OK;
+}
+// This entry's expiration time should match the main entry's expiration
+// time.  UpdateExpirationTime() will keep it in sync once the offline
+// cache entry has been created.
+if (mCacheEntry) {
+uint32_t expirationTime;
+nsresult rv = mCacheEntry->GetExpirationTime(&expirationTime);
+NS_ENSURE_SUCCESS(rv, rv);
+mOfflineCacheEntry->SetExpirationTime(expirationTime);
+}
+return AddCacheEntryHeaders(mOfflineCacheEntry);
+}
+nsresult
+nsHttpChannel::AddCacheEntryHeaders(nsICacheEntry *entry)
+{
+nsresult rv;
+LOG(("nsHttpChannel::AddCacheEntryHeaders [this=%p] begin", this));
+// Store secure data in memory only
+if (mSecurityInfo)
+entry->SetSecurityInfo(mSecurityInfo);
+// Store the HTTP request method with the cache entry so we can distinguish
+// for example GET and HEAD responses.
+rv = entry->SetMetaDataElement("request-method",
+mRequestHead.Method().get());
+if (NS_FAILED(rv)) return rv;
+// Store the HTTP authorization scheme used if any...
+rv = StoreAuthorizationMetaData(entry);
+if (NS_FAILED(rv)) return rv;
+// Iterate over the headers listed in the Vary response header, and
+// store the value of the corresponding request header so we can verify
+// that it has not varied when we try to re-use the cached response at
+// a later time.  Take care to store "Cookie" headers only as hashes
+// due to security considerations and the fact that they can be pretty
+// large (bug 468426). We take care of "Vary: cookie" in ResponseWouldVary.
+//
+// NOTE: if "Vary: accept, cookie", then we will store the "accept" header
+// in the cache.  we could try to avoid needlessly storing the "accept"
+// header in this case, but it doesn't seem worth the extra code to perform
+// the check.
+{
+nsAutoCString buf, metaKey;
+mResponseHead->GetHeader(nsHttp::Vary, buf);
+if (!buf.IsEmpty()) {
+NS_NAMED_LITERAL_CSTRING(prefix, "request-");
+char *val = buf.BeginWriting(); // going to munge buf
+char *token = nsCRT::strtok(val, NS_HTTP_HEADER_SEPS, &val);
+while (token) {
+LOG(("nsHttpChannel::AddCacheEntryHeaders [this=%p] " \
+"processing %s", this, token));
+if (*token != '*') {
+nsHttpAtom atom = nsHttp::ResolveAtom(token);
+const char *val = mRequestHead.PeekHeader(atom);
+nsAutoCString hash;
+if (val) {
+// If cookie-header, store a hash of the value
+if (atom == nsHttp::Cookie) {
+LOG(("nsHttpChannel::AddCacheEntryHeaders [this=%p] " \
+"cookie-value %s", this, val));
+rv = Hash(val, hash);
+// If hash failed, store a string not very likely
+// to be the result of subsequent hashes
+if (NS_FAILED(rv))
+val = "<hash failed>";
+else
+val = hash.get();
+LOG(("   hashed to %s\n", val));
+}
+// build cache meta data key and set meta data element...
+metaKey = prefix + nsDependentCString(token);
+entry->SetMetaDataElement(metaKey.get(), val);
+} else {
+LOG(("nsHttpChannel::AddCacheEntryHeaders [this=%p] " \
+"clearing metadata for %s", this, token));
+metaKey = prefix + nsDependentCString(token);
+entry->SetMetaDataElement(metaKey.get(), nullptr);
+}
+}
+token = nsCRT::strtok(val, NS_HTTP_HEADER_SEPS, &val);
+}
+}
+}
+// Store the received HTTP head with the cache entry as an element of
+// the meta data.
+nsAutoCString head;
+mResponseHead->Flatten(head, true);
+rv = entry->SetMetaDataElement("response-head", head.get());
+if (NS_FAILED(rv)) return rv;
+// Indicate we have successfully finished setting metadata on the cache entry.
+rv = entry->MetaDataReady();
+return rv;
+}
+inline void
+GetAuthType(const char *challenge, nsCString &authType)
+{
+const char *p;
+// get the challenge type
+if ((p = strchr(challenge, ' ')) != nullptr)
+authType.Assign(challenge, p - challenge);
+else
+authType.Assign(challenge);
+}
+nsresult
+nsHttpChannel::StoreAuthorizationMetaData(nsICacheEntry *entry)
+{
+// Not applicable to proxy authorization...
+const char *val = mRequestHead.PeekHeader(nsHttp::Authorization);
+if (!val)
+return NS_OK;
+// eg. [Basic realm="wally world"]
+nsAutoCString buf;
+GetAuthType(val, buf);
+return entry->SetMetaDataElement("auth", buf.get());
+}
+// Finalize the cache entry
+//  - may need to rewrite response headers if any headers changed
+//  - may need to recalculate the expiration time if any headers changed
+//  - called only for freshly written cache entries
+nsresult
+nsHttpChannel::FinalizeCacheEntry()
+{
+LOG(("nsHttpChannel::FinalizeCacheEntry [this=%p]\n", this));
+if (mResponseHead && mResponseHeadersModified) {
+// Set the expiration time for this cache entry
+nsresult rv = UpdateExpirationTime();
+if (NS_FAILED(rv)) return rv;
+}
+return NS_OK;
+}
+// Open an output stream to the cache entry and insert a listener tee into
+// the chain of response listeners.
+nsresult
+nsHttpChannel::InstallCacheListener(int64_t offset)
+{
+nsresult rv;
+LOG(("Preparing to write data into the cache [uri=%s]\n", mSpec.get()));
+MOZ_ASSERT(mCacheEntry);
+MOZ_ASSERT(mCacheEntryIsWriteOnly || mCachedContentIsPartial);
+MOZ_ASSERT(mListener);
+// If the content is compressible and the server has not compressed it,
+// mark the cache entry for compression.
+if ((mResponseHead->PeekHeader(nsHttp::Content_Encoding) == nullptr) && (
+mResponseHead->ContentType().EqualsLiteral(TEXT_HTML) ||
+mResponseHead->ContentType().EqualsLiteral(TEXT_PLAIN) ||
+mResponseHead->ContentType().EqualsLiteral(TEXT_CSS) ||
+mResponseHead->ContentType().EqualsLiteral(TEXT_JAVASCRIPT) ||
+mResponseHead->ContentType().EqualsLiteral(TEXT_ECMASCRIPT) ||
+mResponseHead->ContentType().EqualsLiteral(TEXT_XML) ||
+mResponseHead->ContentType().EqualsLiteral(APPLICATION_JAVASCRIPT) ||
+mResponseHead->ContentType().EqualsLiteral(APPLICATION_ECMASCRIPT) ||
+mResponseHead->ContentType().EqualsLiteral(APPLICATION_XJAVASCRIPT) ||
+mResponseHead->ContentType().EqualsLiteral(APPLICATION_XHTML_XML))) {
+rv = mCacheEntry->SetMetaDataElement("uncompressed-len", "0");
+if (NS_FAILED(rv)) {
+LOG(("unable to mark cache entry for compression"));
+}
+}
+LOG(("Trading cache input stream for output stream [channel=%p]", this));
+// We must close the input stream first because cache entries do not
+// correctly handle having an output stream and input streams open at
+// the same time.
+mCacheInputStream.CloseAndRelease();
+nsCOMPtr<nsIOutputStream> out;
+rv = mCacheEntry->OpenOutputStream(offset, getter_AddRefs(out));
+if (rv == NS_ERROR_NOT_AVAILABLE) {
+LOG(("  entry doomed, not writing it [channel=%p]", this));
+// Entry is already doomed.
+// This may happen when expiration time is set to past and the entry
+// has been removed by the background eviction logic.
+return NS_OK;
+}
+if (NS_FAILED(rv)) return rv;
+// XXX disk cache does not support overlapped i/o yet
+#if 0
+// Mark entry valid inorder to allow simultaneous reading...
+rv = mCacheEntry->MarkValid();
+if (NS_FAILED(rv)) return rv;
+#endif
+nsCOMPtr<nsIStreamListenerTee> tee =
+do_CreateInstance(kStreamListenerTeeCID, &rv);
+if (NS_FAILED(rv)) return rv;
+nsCOMPtr<nsICacheStorageService> serv =
+do_GetService("@mozilla.org/netwerk/cache-storage-service;1", &rv);
+NS_ENSURE_SUCCESS(rv, rv);
+nsCOMPtr<nsIEventTarget> cacheIOTarget;
+serv->GetIoTarget(getter_AddRefs(cacheIOTarget));
+if (!cacheIOTarget) {
+LOG(("nsHttpChannel::InstallCacheListener sync tee %p rv=%x "
+"cacheIOTarget=%p", tee.get(), rv, cacheIOTarget.get()));
+rv = tee->Init(mListener, out, nullptr);
+} else {
+LOG(("nsHttpChannel::InstallCacheListener async tee %p", tee.get()));
+rv = tee->InitAsync(mListener, cacheIOTarget, out, nullptr);
+}
+if (NS_FAILED(rv)) return rv;
+mListener = tee;
+return NS_OK;
+}
+nsresult
+nsHttpChannel::InstallOfflineCacheListener(int64_t offset)
+{
+nsresult rv;
+LOG(("Preparing to write data into the offline cache [uri=%s]\n",
+mSpec.get()));
+MOZ_ASSERT(mOfflineCacheEntry);
+MOZ_ASSERT(mListener);
+nsCOMPtr<nsIOutputStream> out;
+rv = mOfflineCacheEntry->OpenOutputStream(offset, getter_AddRefs(out));
+if (NS_FAILED(rv)) return rv;
+nsCOMPtr<nsIStreamListenerTee> tee =
+do_CreateInstance(kStreamListenerTeeCID, &rv);
+if (NS_FAILED(rv)) return rv;
+rv = tee->Init(mListener, out, nullptr);
+if (NS_FAILED(rv)) return rv;
+mListener = tee;
+return NS_OK;
+}
+void
+nsHttpChannel::ClearBogusContentEncodingIfNeeded()
+{
+// For .gz files, apache sends both a Content-Type: application/x-gzip
+// as well as Content-Encoding: gzip, which is completely wrong.  In
+// this case, we choose to ignore the rogue Content-Encoding header. We
+// must do this early on so as to prevent it from being seen up stream.
+// The same problem exists for Content-Encoding: compress in default
+// Apache installs.
+if (mResponseHead->HasHeaderValue(nsHttp::Content_Encoding, "gzip") && (
+mResponseHead->ContentType().EqualsLiteral(APPLICATION_GZIP) ||
+mResponseHead->ContentType().EqualsLiteral(APPLICATION_GZIP2) ||
+mResponseHead->ContentType().EqualsLiteral(APPLICATION_GZIP3))) {
+// clear the Content-Encoding header
+mResponseHead->ClearHeader(nsHttp::Content_Encoding);
+}
+else if (mResponseHead->HasHeaderValue(nsHttp::Content_Encoding, "compress") && (
+mResponseHead->ContentType().EqualsLiteral(APPLICATION_COMPRESS) ||
+mResponseHead->ContentType().EqualsLiteral(APPLICATION_COMPRESS2))) {
+// clear the Content-Encoding header
+mResponseHead->ClearHeader(nsHttp::Content_Encoding);
+}
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel <redirect>
+//-----------------------------------------------------------------------------
+nsresult
+nsHttpChannel::SetupReplacementChannel(nsIURI       *newURI,
+nsIChannel   *newChannel,
+bool          preserveMethod)
+{
+LOG(("nsHttpChannel::SetupReplacementChannel "
+"[this=%p newChannel=%p preserveMethod=%d]",
+this, newChannel, preserveMethod));
+nsresult rv = HttpBaseChannel::SetupReplacementChannel(newURI, newChannel, preserveMethod);
+if (NS_FAILED(rv))
+return rv;
+nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(newChannel);
+if (!httpChannel)
+return NS_OK; // no other options to set
+// convey the mApplyConversion flag (bug 91862)
+nsCOMPtr<nsIEncodedChannel> encodedChannel = do_QueryInterface(httpChannel);
+if (encodedChannel)
+encodedChannel->SetApplyConversion(mApplyConversion);
+// transfer the resume information
+if (mResuming) {
+nsCOMPtr<nsIResumableChannel> resumableChannel(do_QueryInterface(newChannel));
+if (!resumableChannel) {
+NS_WARNING("Got asked to resume, but redirected to non-resumable channel!");
+return NS_ERROR_NOT_RESUMABLE;
+}
+resumableChannel->ResumeAt(mStartPos, mEntityID);
+}
+return NS_OK;
+}
+nsresult
+nsHttpChannel::AsyncProcessRedirection(uint32_t redirectType)
+{
+LOG(("nsHttpChannel::AsyncProcessRedirection [this=%p type=%u]\n",
+this, redirectType));
+// The channel is actually starting its operation now, at least because
+// we want it to appear like being in the waiting phase until now.
+MOZ_EVENT_TRACER_EXEC(this, "net::http::channel");
+MOZ_EVENT_TRACER_EXEC(this, "net::http::redirect-callbacks");
+const char *location = mResponseHead->PeekHeader(nsHttp::Location);
+// if a location header was not given, then we can't perform the redirect,
+// so just carry on as though this were a normal response.
+if (!location)
+return NS_ERROR_FAILURE;
+// make sure non-ASCII characters in the location header are escaped.
+nsAutoCString locationBuf;
+if (NS_EscapeURL(location, -1, esc_OnlyNonASCII, locationBuf))
+location = locationBuf.get();
+if (mRedirectionLimit == 0) {
+LOG(("redirection limit reached!\n"));
+return NS_ERROR_REDIRECT_LOOP;
+}
+mRedirectType = redirectType;
+LOG(("redirecting to: %s [redirection-limit=%u]\n",
+location, uint32_t(mRedirectionLimit)));
+nsresult rv = CreateNewURI(location, getter_AddRefs(mRedirectURI));
+if (NS_FAILED(rv)) {
+LOG(("Invalid URI for redirect: Location: %s\n", location));
+return NS_ERROR_CORRUPTED_CONTENT;
+}
+if (mApplicationCache) {
+// if we are redirected to a different origin check if there is a fallback
+// cache entry to fall back to. we don't care about file strict
+// checking, at least mURI is not a file URI.
+if (!NS_SecurityCompareURIs(mURI, mRedirectURI, false)) {
+PushRedirectAsyncFunc(&nsHttpChannel::ContinueProcessRedirectionAfterFallback);
+bool waitingForRedirectCallback;
+(void)ProcessFallback(&waitingForRedirectCallback);
+if (waitingForRedirectCallback)
+return NS_OK;
+PopRedirectAsyncFunc(&nsHttpChannel::ContinueProcessRedirectionAfterFallback);
+}
+}
+return ContinueProcessRedirectionAfterFallback(NS_OK);
+}
+// Creates an URI to the given location using current URI for base and charset
+nsresult
+nsHttpChannel::CreateNewURI(const char *loc, nsIURI **newURI)
+{
+nsCOMPtr<nsIIOService> ioService;
+nsresult rv = gHttpHandler->GetIOService(getter_AddRefs(ioService));
+if (NS_FAILED(rv)) return rv;
+// the new uri should inherit the origin charset of the current uri
+nsAutoCString originCharset;
+rv = mURI->GetOriginCharset(originCharset);
+if (NS_FAILED(rv))
+originCharset.Truncate();
+return ioService->NewURI(nsDependentCString(loc),
+originCharset.get(),
+mURI,
+newURI);
+}
+nsresult
+nsHttpChannel::ContinueProcessRedirectionAfterFallback(nsresult rv)
+{
+if (NS_SUCCEEDED(rv) && mFallingBack) {
+// do not continue with redirect processing, fallback is in
+// progress now.
+return NS_OK;
+}
+// Kill the current cache entry if we are redirecting
+// back to ourself.
+bool redirectingBackToSameURI = false;
+if (mCacheEntry && mCacheEntryIsWriteOnly &&
+NS_SUCCEEDED(mURI->Equals(mRedirectURI, &redirectingBackToSameURI)) &&
+redirectingBackToSameURI)
+mCacheEntry->AsyncDoom(nullptr);
+// move the reference of the old location to the new one if the new
+// one has none.
+nsAutoCString ref;
+rv = mRedirectURI->GetRef(ref);
+if (NS_SUCCEEDED(rv) && ref.IsEmpty()) {
+mURI->GetRef(ref);
+if (!ref.IsEmpty()) {
+// NOTE: SetRef will fail if mRedirectURI is immutable
+// (e.g. an about: URI)... Oh well.
+mRedirectURI->SetRef(ref);
+}
+}
+bool rewriteToGET = ShouldRewriteRedirectToGET(mRedirectType,
+mRequestHead.ParsedMethod());
+// prompt if the method is not safe (such as POST, PUT, DELETE, ...)
+if (!rewriteToGET && !mRequestHead.IsSafeMethod()) {
+rv = PromptTempRedirect();
+if (NS_FAILED(rv)) return rv;
+}
+nsCOMPtr<nsIIOService> ioService;
+rv = gHttpHandler->GetIOService(getter_AddRefs(ioService));
+if (NS_FAILED(rv)) return rv;
+nsCOMPtr<nsIChannel> newChannel;
+rv = ioService->NewChannelFromURI(mRedirectURI, getter_AddRefs(newChannel));
+if (NS_FAILED(rv)) return rv;
+rv = SetupReplacementChannel(mRedirectURI, newChannel, !rewriteToGET);
+if (NS_FAILED(rv)) return rv;
+uint32_t redirectFlags;
+if (nsHttp::IsPermanentRedirect(mRedirectType))
+redirectFlags = nsIChannelEventSink::REDIRECT_PERMANENT;
+else
+redirectFlags = nsIChannelEventSink::REDIRECT_TEMPORARY;
+// verify that this is a legal redirect
+mRedirectChannel = newChannel;
+PushRedirectAsyncFunc(&nsHttpChannel::ContinueProcessRedirection);
+rv = gHttpHandler->AsyncOnChannelRedirect(this, newChannel, redirectFlags);
+if (NS_SUCCEEDED(rv))
+rv = WaitForRedirectCallback();
+if (NS_FAILED(rv)) {
+AutoRedirectVetoNotifier notifier(this);
+PopRedirectAsyncFunc(&nsHttpChannel::ContinueProcessRedirection);
+}
+return rv;
+}
+nsresult
+nsHttpChannel::ContinueProcessRedirection(nsresult rv)
+{
+AutoRedirectVetoNotifier notifier(this);
+LOG(("ContinueProcessRedirection [rv=%x]\n", rv));
+if (NS_FAILED(rv))
+return rv;
+NS_PRECONDITION(mRedirectChannel, "No redirect channel?");
+// Make sure to do this _after_ calling OnChannelRedirect
+mRedirectChannel->SetOriginalURI(mOriginalURI);
+// And now, the deprecated way
+nsCOMPtr<nsIHttpEventSink> httpEventSink;
+GetCallback(httpEventSink);
+if (httpEventSink) {
+// NOTE: nsIHttpEventSink is only used for compatibility with pre-1.8
+// versions.
+rv = httpEventSink->OnRedirect(this, mRedirectChannel);
+if (NS_FAILED(rv))
+return rv;
+}
+// XXX we used to talk directly with the script security manager, but that
+// should really be handled by the event sink implementation.
+// begin loading the new channel
+rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);
+if (NS_FAILED(rv))
+return rv;
+// close down this channel
+Cancel(NS_BINDING_REDIRECTED);
+notifier.RedirectSucceeded();
+ReleaseListeners();
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel <auth>
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP nsHttpChannel::OnAuthAvailable()
+{
+LOG(("nsHttpChannel::OnAuthAvailable [this=%p]", this));
+// setting mAuthRetryPending flag and resuming the transaction
+// triggers process of throwing away the unauthenticated data already
+// coming from the network
+mAuthRetryPending = true;
+mProxyAuthPending = false;
+LOG(("Resuming the transaction, we got credentials from user"));
+mTransactionPump->Resume();
+return NS_OK;
+}
+NS_IMETHODIMP nsHttpChannel::OnAuthCancelled(bool userCancel)
+{
+LOG(("nsHttpChannel::OnAuthCancelled [this=%p]", this));
+if (mTransactionPump) {
+// If the channel is trying to authenticate to a proxy and
+// that was canceled we cannot show the http response body
+// from the 40x as that might mislead the user into thinking
+// it was a end host response instead of a proxy reponse.
+// This must check explicitly whether a proxy auth was being done
+// because we do want to show the content if this is an error from
+// the origin server.
+if (mProxyAuthPending)
+Cancel(NS_ERROR_PROXY_CONNECTION_REFUSED);
+// ensure call of OnStartRequest of the current listener here,
+// it would not be called otherwise at all
+nsresult rv = CallOnStartRequest();
+// drop mAuthRetryPending flag and resume the transaction
+// this resumes load of the unauthenticated content data (which
+// may have been canceled if we don't want to show it)
+mAuthRetryPending = false;
+LOG(("Resuming the transaction, user cancelled the auth dialog"));
+mTransactionPump->Resume();
+if (NS_FAILED(rv))
+mTransactionPump->Cancel(rv);
+}
+mProxyAuthPending = false;
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsISupports
+//-----------------------------------------------------------------------------
+NS_IMPL_ADDREF_INHERITED(nsHttpChannel, HttpBaseChannel)
+NS_IMPL_RELEASE_INHERITED(nsHttpChannel, HttpBaseChannel)
+NS_INTERFACE_MAP_BEGIN(nsHttpChannel)
+NS_INTERFACE_MAP_ENTRY(nsIRequest)
+NS_INTERFACE_MAP_ENTRY(nsIChannel)
+NS_INTERFACE_MAP_ENTRY(nsIRequestObserver)
+NS_INTERFACE_MAP_ENTRY(nsIStreamListener)
+NS_INTERFACE_MAP_ENTRY(nsIHttpChannel)
+NS_INTERFACE_MAP_ENTRY(nsICacheInfoChannel)
+NS_INTERFACE_MAP_ENTRY(nsICachingChannel)
+NS_INTERFACE_MAP_ENTRY(nsIUploadChannel)
+NS_INTERFACE_MAP_ENTRY(nsIUploadChannel2)
+NS_INTERFACE_MAP_ENTRY(nsICacheEntryOpenCallback)
+NS_INTERFACE_MAP_ENTRY(nsIHttpChannelInternal)
+NS_INTERFACE_MAP_ENTRY(nsIResumableChannel)
+NS_INTERFACE_MAP_ENTRY(nsITransportEventSink)
+NS_INTERFACE_MAP_ENTRY(nsISupportsPriority)
+NS_INTERFACE_MAP_ENTRY(nsIProtocolProxyCallback)
+NS_INTERFACE_MAP_ENTRY(nsIProxiedChannel)
+NS_INTERFACE_MAP_ENTRY(nsIHttpAuthenticableChannel)
+NS_INTERFACE_MAP_ENTRY(nsIApplicationCacheContainer)
+NS_INTERFACE_MAP_ENTRY(nsIApplicationCacheChannel)
+NS_INTERFACE_MAP_ENTRY(nsIAsyncVerifyRedirectCallback)
+NS_INTERFACE_MAP_ENTRY(nsIThreadRetargetableRequest)
+NS_INTERFACE_MAP_ENTRY(nsIThreadRetargetableStreamListener)
+NS_INTERFACE_MAP_ENTRY(nsIDNSListener)
+NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+NS_INTERFACE_MAP_END_INHERITING(HttpBaseChannel)
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsIRequest
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::Cancel(nsresult status)
+{
+MOZ_ASSERT(NS_IsMainThread());
+LOG(("nsHttpChannel::Cancel [this=%p status=%x]\n", this, status));
+if (mCanceled) {
+LOG(("  ignoring; already canceled\n"));
+return NS_OK;
+}
+if (mWaitingForRedirectCallback) {
+LOG(("channel canceled during wait for redirect callback"));
+}
+mCanceled = true;
+mStatus = status;
+if (mProxyRequest)
+mProxyRequest->Cancel(status);
+if (mTransaction)
+gHttpHandler->CancelTransaction(mTransaction, status);
+if (mTransactionPump)
+mTransactionPump->Cancel(status);
+mCacheInputStream.CloseAndRelease();
+if (mCachePump)
+mCachePump->Cancel(status);
+if (mAuthProvider)
+mAuthProvider->Cancel(status);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::Suspend()
+{
+NS_ENSURE_TRUE(mIsPending, NS_ERROR_NOT_AVAILABLE);
+LOG(("nsHttpChannel::Suspend [this=%p]\n", this));
+++mSuspendCount;
+if (mTransactionPump)
+return mTransactionPump->Suspend();
+if (mCachePump)
+return mCachePump->Suspend();
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::Resume()
+{
+NS_ENSURE_TRUE(mSuspendCount > 0, NS_ERROR_UNEXPECTED);
+LOG(("nsHttpChannel::Resume [this=%p]\n", this));
+if (--mSuspendCount == 0 && mCallOnResume) {
+nsresult rv = AsyncCall(mCallOnResume);
+mCallOnResume = nullptr;
+NS_ENSURE_SUCCESS(rv, rv);
+}
+if (mTransactionPump)
+return mTransactionPump->Resume();
+if (mCachePump)
+return mCachePump->Resume();
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsIChannel
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::GetSecurityInfo(nsISupports **securityInfo)
+{
+NS_ENSURE_ARG_POINTER(securityInfo);
+*securityInfo = mSecurityInfo;
+NS_IF_ADDREF(*securityInfo);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *context)
+{
+MOZ_EVENT_TRACER_WAIT(this, "net::http::channel");
+LOG(("nsHttpChannel::AsyncOpen [this=%p]\n", this));
+NS_ENSURE_ARG_POINTER(listener);
+NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);
+NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
+nsresult rv;
+rv = NS_CheckPortSafety(mURI);
+if (NS_FAILED(rv)) {
+ReleaseListeners();
+return rv;
+}
+// Remember the cookie header that was set, if any
+const char *cookieHeader = mRequestHead.PeekHeader(nsHttp::Cookie);
+if (cookieHeader) {
+mUserSetCookieHeader = cookieHeader;
+}
+AddCookiesToRequest();
+// notify "http-on-opening-request" observers, but not if this is a redirect
+if (!(mLoadFlags & LOAD_REPLACE)) {
+gHttpHandler->OnOpeningRequest(this);
+}
+mIsPending = true;
+mWasOpened = true;
+mListener = listener;
+mListenerContext = context;
+// add ourselves to the load group.  from this point forward, we'll report
+// all failures asynchronously.
+if (mLoadGroup)
+mLoadGroup->AddRequest(this, nullptr);
+// record asyncopen time unconditionally and clear it if we
+// don't want it after OnModifyRequest() weighs in. But waiting for
+// that to complete would mean we don't include proxy resolution in the
+// timing.
+mAsyncOpenTime = TimeStamp::Now();
+// the only time we would already know the proxy information at this
+// point would be if we were proxying a non-http protocol like ftp
+if (!mProxyInfo && NS_SUCCEEDED(ResolveProxy()))
+return NS_OK;
+rv = BeginConnect();
+if (NS_FAILED(rv))
+ReleaseListeners();
+return rv;
+}
+nsresult
+nsHttpChannel::BeginConnect()
+{
+LOG(("nsHttpChannel::BeginConnect [this=%p]\n", this));
+nsresult rv;
+// Construct connection info object
+nsAutoCString host;
+int32_t port = -1;
+nsAutoCString username;
+bool usingSSL = false;
+rv = mURI->SchemeIs("https", &usingSSL);
+if (NS_SUCCEEDED(rv))
+rv = mURI->GetAsciiHost(host);
+if (NS_SUCCEEDED(rv))
+rv = mURI->GetPort(&port);
+if (NS_SUCCEEDED(rv))
+mURI->GetUsername(username);
+if (NS_SUCCEEDED(rv))
+rv = mURI->GetAsciiSpec(mSpec);
+if (NS_FAILED(rv))
+return rv;
+// Reject the URL if it doesn't specify a host
+if (host.IsEmpty())
+return NS_ERROR_MALFORMED_URI;
+LOG(("host=%s port=%d\n", host.get(), port));
+LOG(("uri=%s\n", mSpec.get()));
+nsCOMPtr<nsProxyInfo> proxyInfo;
+if (mProxyInfo)
+proxyInfo = do_QueryInterface(mProxyInfo);
+mConnectionInfo = new nsHttpConnectionInfo(host, port, username, proxyInfo, usingSSL);
+mAuthProvider =
+do_CreateInstance("@mozilla.org/network/http-channel-auth-provider;1",
+&rv);
+if (NS_SUCCEEDED(rv))
+rv = mAuthProvider->Init(this);
+if (NS_FAILED(rv))
+return rv;
+// check to see if authorization headers should be included
+mAuthProvider->AddAuthorizationHeaders();
+// notify "http-on-modify-request" observers
+CallOnModifyRequestObservers();
+// Check to see if we should redirect this channel elsewhere by
+// nsIHttpChannel.redirectTo API request
+if (mAPIRedirectToURI) {
+return AsyncCall(&nsHttpChannel::HandleAsyncAPIRedirect);
+}
+// If mTimingEnabled flag is not set after OnModifyRequest() then
+// clear the already recorded AsyncOpen value for consistency.
+if (!mTimingEnabled)
+mAsyncOpenTime = TimeStamp();
+// when proxying only use the pipeline bit if ProxyPipelining() allows it.
+if (!mConnectionInfo->UsingConnect() && mConnectionInfo->UsingHttpProxy()) {
+mCaps &= ~NS_HTTP_ALLOW_PIPELINING;
+if (gHttpHandler->ProxyPipelining())
+mCaps |= NS_HTTP_ALLOW_PIPELINING;
+}
+// if this somehow fails we can go on without it
+gHttpHandler->AddConnectionHeader(&mRequestHead.Headers(), mCaps);
+if (mLoadFlags & VALIDATE_ALWAYS || BYPASS_LOCAL_CACHE(mLoadFlags))
+mCaps |= NS_HTTP_REFRESH_DNS;
+if (!mConnectionInfo->UsingHttpProxy()) {
+// Start a DNS lookup very early in case the real open is queued the DNS can
+// happen in parallel. Do not do so in the presence of an HTTP proxy as
+// all lookups other than for the proxy itself are done by the proxy.
+//
+// We keep the DNS prefetch object around so that we can retrieve
+// timing information from it. There is no guarantee that we actually
+// use the DNS prefetch data for the real connection, but as we keep
+// this data around for 3 minutes by default, this should almost always
+// be correct, and even when it isn't, the timing still represents _a_
+// valid DNS lookup timing for the site, even if it is not _the_
+// timing we used.
+LOG(("nsHttpChannel::BeginConnect [this=%p] prefetching%s\n",
+this, mCaps & NS_HTTP_REFRESH_DNS ? ", refresh requested" : ""));
+mDNSPrefetch = new nsDNSPrefetch(mURI, this, mTimingEnabled);
+mDNSPrefetch->PrefetchHigh(mCaps & NS_HTTP_REFRESH_DNS);
+}
+// Adjust mCaps according to our request headers:
+//  - If "Connection: close" is set as a request header, then do not bother
+//    trying to establish a keep-alive connection.
+if (mRequestHead.HasHeaderValue(nsHttp::Connection, "close"))
+mCaps &= ~(NS_HTTP_ALLOW_KEEPALIVE | NS_HTTP_ALLOW_PIPELINING);
+if (gHttpHandler->CriticalRequestPrioritization()) {
+if (mLoadAsBlocking)
+mCaps |= NS_HTTP_LOAD_AS_BLOCKING;
+if (mLoadUnblocked)
+mCaps |= NS_HTTP_LOAD_UNBLOCKED;
+}
+// Force-Reload should reset the persistent connection pool for this host
+if (mLoadFlags & LOAD_FRESH_CONNECTION) {
+// just the initial document resets the whole pool
+if (mLoadFlags & LOAD_INITIAL_DOCUMENT_URI) {
+gHttpHandler->ConnMgr()->DoShiftReloadConnectionCleanup(mConnectionInfo);
+}
+// each sub resource gets a fresh connection
+mCaps &= ~(NS_HTTP_ALLOW_KEEPALIVE | NS_HTTP_ALLOW_PIPELINING);
+}
+// We may have been cancelled already, either by on-modify-request
+// listeners or by load group observers; in that case, we should
+// not send the request to the server
+if (mCanceled)
+rv = mStatus;
+else
+rv = Connect();
+if (NS_FAILED(rv)) {
+LOG(("Calling AsyncAbort [rv=%x mCanceled=%i]\n", rv, mCanceled));
+CloseCacheEntry(true);
+AsyncAbort(rv);
+} else if (mLoadFlags & LOAD_CLASSIFY_URI) {
+nsRefPtr<nsChannelClassifier> classifier = new nsChannelClassifier();
+rv = classifier->Start(this);
+if (NS_FAILED(rv)) {
+Cancel(rv);
+return rv;
+}
+}
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsIHttpChannelInternal
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::SetupFallbackChannel(const char *aFallbackKey)
+{
+ENSURE_CALLED_BEFORE_CONNECT();
+LOG(("nsHttpChannel::SetupFallbackChannel [this=%p, key=%s]",
+this, aFallbackKey));
+mFallbackChannel = true;
+mFallbackKey = aFallbackKey;
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsISupportsPriority
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::SetPriority(int32_t value)
+{
+int16_t newValue = clamped<int32_t>(value, INT16_MIN, INT16_MAX);
+if (mPriority == newValue)
+return NS_OK;
+mPriority = newValue;
+if (mTransaction)
+gHttpHandler->RescheduleTransaction(mTransaction, mPriority);
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsIProtocolProxyCallback
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::OnProxyAvailable(nsICancelable *request, nsIChannel *channel,
+nsIProxyInfo *pi, nsresult status)
+{
+LOG(("nsHttpChannel::OnProxyAvailable [this=%p pi=%p status=%x mStatus=%x]\n",
+this, pi, status, mStatus));
+mProxyRequest = nullptr;
+nsresult rv;
+// If status is a failure code, then it means that we failed to resolve
+// proxy info.  That is a non-fatal error assuming it wasn't because the
+// request was canceled.  We just failover to DIRECT when proxy resolution
+// fails (failure can mean that the PAC URL could not be loaded).
+if (NS_SUCCEEDED(status))
+mProxyInfo = pi;
+if (!gHttpHandler->Active()) {
+LOG(("nsHttpChannel::OnProxyAvailable [this=%p] "
+"Handler no longer active.\n", this));
+rv = NS_ERROR_NOT_AVAILABLE;
+}
+else {
+rv = BeginConnect();
+}
+if (NS_FAILED(rv)) {
+Cancel(rv);
+// Calling OnStart/OnStop synchronously here would mean doing it before
+// returning from AsyncOpen which is a contract violation. Do it async.
+nsRefPtr<nsRunnableMethod<HttpBaseChannel> > event =
+NS_NewRunnableMethod(this, &nsHttpChannel::DoNotifyListener);
+rv = NS_DispatchToCurrentThread(event);
+if (NS_FAILED(rv)) {
+NS_WARNING("Failed To Dispatch DoNotifyListener");
+}
+}
+return rv;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsIProxiedChannel
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::GetProxyInfo(nsIProxyInfo **result)
+{
+if (!mConnectionInfo)
+*result = mProxyInfo;
+else
+*result = mConnectionInfo->ProxyInfo();
+NS_IF_ADDREF(*result);
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsITimedChannel
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::GetDomainLookupStart(TimeStamp* _retval) {
+if (mDNSPrefetch && mDNSPrefetch->TimingsValid())
+*_retval = mDNSPrefetch->StartTimestamp();
+else if (mTransaction)
+*_retval = mTransaction->Timings().domainLookupStart;
+else
+*_retval = mTransactionTimings.domainLookupStart;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetDomainLookupEnd(TimeStamp* _retval) {
+if (mDNSPrefetch && mDNSPrefetch->TimingsValid())
+*_retval = mDNSPrefetch->EndTimestamp();
+else if (mTransaction)
+*_retval = mTransaction->Timings().domainLookupEnd;
+else
+*_retval = mTransactionTimings.domainLookupEnd;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetConnectStart(TimeStamp* _retval) {
+if (mTransaction)
+*_retval = mTransaction->Timings().connectStart;
+else
+*_retval = mTransactionTimings.connectStart;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetConnectEnd(TimeStamp* _retval) {
+if (mTransaction)
+*_retval = mTransaction->Timings().connectEnd;
+else
+*_retval = mTransactionTimings.connectEnd;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetRequestStart(TimeStamp* _retval) {
+if (mTransaction)
+*_retval = mTransaction->Timings().requestStart;
+else
+*_retval = mTransactionTimings.requestStart;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetResponseStart(TimeStamp* _retval) {
+if (mTransaction)
+*_retval = mTransaction->Timings().responseStart;
+else
+*_retval = mTransactionTimings.responseStart;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetResponseEnd(TimeStamp* _retval) {
+if (mTransaction)
+*_retval = mTransaction->Timings().responseEnd;
+else
+*_retval = mTransactionTimings.responseEnd;
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsIHttpAuthenticableChannel
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::GetIsSSL(bool *aIsSSL)
+{
+*aIsSSL = mConnectionInfo->UsingSSL();
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetProxyMethodIsConnect(bool *aProxyMethodIsConnect)
+{
+*aProxyMethodIsConnect = mConnectionInfo->UsingConnect();
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetServerResponseHeader(nsACString &value)
+{
+if (!mResponseHead)
+return NS_ERROR_NOT_AVAILABLE;
+return mResponseHead->GetHeader(nsHttp::Server, value);
+}
+NS_IMETHODIMP
+nsHttpChannel::GetProxyChallenges(nsACString &value)
+{
+if (!mResponseHead)
+return NS_ERROR_UNEXPECTED;
+return mResponseHead->GetHeader(nsHttp::Proxy_Authenticate, value);
+}
+NS_IMETHODIMP
+nsHttpChannel::GetWWWChallenges(nsACString &value)
+{
+if (!mResponseHead)
+return NS_ERROR_UNEXPECTED;
+return mResponseHead->GetHeader(nsHttp::WWW_Authenticate, value);
+}
+NS_IMETHODIMP
+nsHttpChannel::SetProxyCredentials(const nsACString &value)
+{
+return mRequestHead.SetHeader(nsHttp::Proxy_Authorization, value);
+}
+NS_IMETHODIMP
+nsHttpChannel::SetWWWCredentials(const nsACString &value)
+{
+return mRequestHead.SetHeader(nsHttp::Authorization, value);
+}
+//-----------------------------------------------------------------------------
+// Methods that nsIHttpAuthenticableChannel dupes from other IDLs, which we
+// get from HttpBaseChannel, must be explicitly forwarded, because C++ sucks.
+//
+NS_IMETHODIMP
+nsHttpChannel::GetLoadFlags(nsLoadFlags *aLoadFlags)
+{
+return HttpBaseChannel::GetLoadFlags(aLoadFlags);
+}
+NS_IMETHODIMP
+nsHttpChannel::GetURI(nsIURI **aURI)
+{
+return HttpBaseChannel::GetURI(aURI);
+}
+NS_IMETHODIMP
+nsHttpChannel::GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks)
+{
+return HttpBaseChannel::GetNotificationCallbacks(aCallbacks);
+}
+NS_IMETHODIMP
+nsHttpChannel::GetLoadGroup(nsILoadGroup **aLoadGroup)
+{
+return HttpBaseChannel::GetLoadGroup(aLoadGroup);
+}
+NS_IMETHODIMP
+nsHttpChannel::GetRequestMethod(nsACString& aMethod)
+{
+return HttpBaseChannel::GetRequestMethod(aMethod);
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsIRequestObserver
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::OnStartRequest(nsIRequest *request, nsISupports *ctxt)
+{
+PROFILER_LABEL("nsHttpChannel", "OnStartRequest");
+if (!(mCanceled || NS_FAILED(mStatus))) {
+// capture the request's status, so our consumers will know ASAP of any
+// connection failures, etc - bug 93581
+request->GetStatus(&mStatus);
+}
+LOG(("nsHttpChannel::OnStartRequest [this=%p request=%p status=%x]\n",
+this, request, mStatus));
+// Make sure things are what we expect them to be...
+MOZ_ASSERT(request == mCachePump || request == mTransactionPump,
+"Unexpected request");
+MOZ_ASSERT(!(mTransactionPump && mCachePump) || mCachedContentIsPartial,
+"If we have both pumps, the cache content must be partial");
+if (!mSecurityInfo && !mCachePump && mTransaction) {
+// grab the security info from the connection object; the transaction
+// is guaranteed to own a reference to the connection.
+mSecurityInfo = mTransaction->SecurityInfo();
+}
+// don't enter this block if we're reading from the cache...
+if (NS_SUCCEEDED(mStatus) && !mCachePump && mTransaction) {
+// mTransactionPump doesn't hit OnInputStreamReady and call this until
+// all of the response headers have been acquired, so we can take ownership
+// of them from the transaction.
+mResponseHead = mTransaction->TakeResponseHead();
+// the response head may be null if the transaction was cancelled.  in
+// which case we just need to call OnStartRequest/OnStopRequest.
+if (mResponseHead)
+return ProcessResponse();
+NS_WARNING("No response head in OnStartRequest");
+}
+// cache file could be deleted on our behalf, reload from network here.
+if (mCacheEntry && mCachePump && CACHE_FILE_GONE(mStatus)) {
+LOG(("  cache file gone, reloading from server"));
+mCacheEntry->AsyncDoom(nullptr);
+nsresult rv = StartRedirectChannelToURI(mURI, nsIChannelEventSink::REDIRECT_INTERNAL);
+if (NS_SUCCEEDED(rv))
+return NS_OK;
+}
+// avoid crashing if mListener happens to be null...
+if (!mListener) {
+NS_NOTREACHED("mListener is null");
+return NS_OK;
+}
+// on proxy errors, try to failover
+if (mConnectionInfo->ProxyInfo() &&
+(mStatus == NS_ERROR_PROXY_CONNECTION_REFUSED ||
+mStatus == NS_ERROR_UNKNOWN_PROXY_HOST ||
+mStatus == NS_ERROR_NET_TIMEOUT)) {
+PushRedirectAsyncFunc(&nsHttpChannel::ContinueOnStartRequest1);
+if (NS_SUCCEEDED(ProxyFailover()))
+return NS_OK;
+PopRedirectAsyncFunc(&nsHttpChannel::ContinueOnStartRequest1);
+}
+return ContinueOnStartRequest2(NS_OK);
+}
+nsresult
+nsHttpChannel::ContinueOnStartRequest1(nsresult result)
+{
+// Success indicates we passed ProxyFailover, in that case we must not continue
+// with this code chain.
+if (NS_SUCCEEDED(result))
+return NS_OK;
+return ContinueOnStartRequest2(result);
+}
+nsresult
+nsHttpChannel::ContinueOnStartRequest2(nsresult result)
+{
+// on other request errors, try to fall back
+if (NS_FAILED(mStatus)) {
+PushRedirectAsyncFunc(&nsHttpChannel::ContinueOnStartRequest3);
+bool waitingForRedirectCallback;
+ProcessFallback(&waitingForRedirectCallback);
+if (waitingForRedirectCallback)
+return NS_OK;
+PopRedirectAsyncFunc(&nsHttpChannel::ContinueOnStartRequest3);
+}
+return ContinueOnStartRequest3(NS_OK);
+}
+nsresult
+nsHttpChannel::ContinueOnStartRequest3(nsresult result)
+{
+if (mFallingBack)
+return NS_OK;
+return CallOnStartRequest();
+}
+NS_IMETHODIMP
+nsHttpChannel::OnStopRequest(nsIRequest *request, nsISupports *ctxt, nsresult status)
+{
+PROFILER_LABEL("network", "nsHttpChannel::OnStopRequest");
+LOG(("nsHttpChannel::OnStopRequest [this=%p request=%p status=%x]\n",
+this, request, status));
+if (mTimingEnabled && request == mCachePump) {
+mCacheReadEnd = TimeStamp::Now();
+}
+// allow content to be cached if it was loaded successfully (bug #482935)
+bool contentComplete = NS_SUCCEEDED(status);
+// honor the cancelation status even if the underlying transaction completed.
+if (mCanceled || NS_FAILED(mStatus))
+status = mStatus;
+if (mCachedContentIsPartial) {
+if (NS_SUCCEEDED(status)) {
+// mTransactionPump should be suspended
+MOZ_ASSERT(request != mTransactionPump,
+"byte-range transaction finished prematurely");
+if (request == mCachePump) {
+bool streamDone;
+status = OnDoneReadingPartialCacheEntry(&streamDone);
+if (NS_SUCCEEDED(status) && !streamDone)
+return status;
+// otherwise, fall through and fire OnStopRequest...
+}
+else if (request == mTransactionPump) {
+MOZ_ASSERT(mConcurentCacheAccess);
+}
+else
+NS_NOTREACHED("unexpected request");
+}
+// Do not to leave the transaction in a suspended state in error cases.
+if (NS_FAILED(status) && mTransaction)
+gHttpHandler->CancelTransaction(mTransaction, status);
+}
+if (mTransaction) {
+// determine if we should call DoAuthRetry
+bool authRetry = mAuthRetryPending && NS_SUCCEEDED(status);
+//
+// grab references to connection in case we need to retry an
+// authentication request over it or use it for an upgrade
+// to another protocol.
+//
+// this code relies on the code in nsHttpTransaction::Close, which
+// tests for NS_HTTP_STICKY_CONNECTION to determine whether or not to
+// keep the connection around after the transaction is finished.
+//
+nsRefPtr<nsAHttpConnection> conn;
+if (authRetry && (mCaps & NS_HTTP_STICKY_CONNECTION)) {
+conn = mTransaction->GetConnectionReference();
+// This is so far a workaround to fix leak when reusing unpersistent
+// connection for authentication retry. See bug 459620 comment 4
+// for details.
+if (conn && !conn->IsPersistent())
+conn = nullptr;
+}
+nsRefPtr<nsAHttpConnection> stickyConn;
+if (mCaps & NS_HTTP_STICKY_CONNECTION)
+stickyConn = mTransaction->GetConnectionReference();
+// at this point, we're done with the transaction
+mTransactionTimings = mTransaction->Timings();
+mTransaction = nullptr;
+mTransactionPump = nullptr;
+// We no longer need the dns prefetch object
+if (mDNSPrefetch && mDNSPrefetch->TimingsValid()) {
+mTransactionTimings.domainLookupStart =
+mDNSPrefetch->StartTimestamp();
+mTransactionTimings.domainLookupEnd =
+mDNSPrefetch->EndTimestamp();
+}
+mDNSPrefetch = nullptr;
+// handle auth retry...
+if (authRetry) {
+mAuthRetryPending = false;
+status = DoAuthRetry(conn);
+if (NS_SUCCEEDED(status))
+return NS_OK;
+}
+// If DoAuthRetry failed, or if we have been cancelled since showing
+// the auth. dialog, then we need to send OnStartRequest now
+if (authRetry || (mAuthRetryPending && NS_FAILED(status))) {
+MOZ_ASSERT(NS_FAILED(status), "should have a failure code here");
+// NOTE: since we have a failure status, we can ignore the return
+// value from onStartRequest.
+if (mListener) {
+mListener->OnStartRequest(this, mListenerContext);
+} else {
+NS_WARNING("OnStartRequest skipped because of null listener");
+}
+}
+// if this transaction has been replaced, then bail.
+if (mTransactionReplaced)
+return NS_OK;
+if (mUpgradeProtocolCallback && stickyConn &&
+mResponseHead && mResponseHead->Status() == 101) {
+gHttpHandler->ConnMgr()->CompleteUpgrade(stickyConn,
+mUpgradeProtocolCallback);
+}
+}
+mIsPending = false;
+// if needed, check cache entry has all data we expect
+if (mCacheEntry && mCachePump &&
+mConcurentCacheAccess && contentComplete) {
+int64_t size, contentLength;
+nsresult rv = CheckPartial(mCacheEntry, &size, &contentLength);
+if (NS_SUCCEEDED(rv)) {
+if (size == int64_t(-1)) {
+// mayhemer TODO - we have to restart read from cache here at the size offset
+MOZ_ASSERT(false);
+LOG(("  cache entry write is still in progress, but we just "
+"finished reading the cache entry"));
+}
+else if (contentLength != int64_t(-1) && contentLength != size) {
+LOG(("  concurrent cache entry write has been interrupted"));
+mCachedResponseHead = mResponseHead;
+rv = MaybeSetupByteRangeRequest(size, contentLength);
+if (NS_SUCCEEDED(rv) && mIsPartialRequest) {
+// Prevent read from cache again
+mCachedContentIsValid = 0;
+mCachedContentIsPartial = 1;
+// Perform the range request
+rv = ContinueConnect();
+if (NS_SUCCEEDED(rv)) {
+LOG(("  performing range request"));
+mCachePump = nullptr;
+return NS_OK;
+} else {
+LOG(("  but range request perform failed 0x%08x", rv));
+status = NS_ERROR_NET_INTERRUPT;
+}
+}
+else {
+LOG(("  but range request setup failed rv=0x%08x, failing load", rv));
+}
+}
+}
+}
+mStatus = status;
+// perform any final cache operations before we close the cache entry.
+if (mCacheEntry && mRequestTimeInitialized) {
+bool writeAccess;
+// New implementation just returns value of the !mCacheEntryIsReadOnly flag passed in.
+// Old implementation checks on nsICache::ACCESS_WRITE flag.
+mCacheEntry->HasWriteAccess(!mCacheEntryIsReadOnly, &writeAccess);
+if (writeAccess) {
+FinalizeCacheEntry();
+}
+}
+// Register entry to the Performance resource timing
+nsPerformance* documentPerformance = GetPerformance();
+if (documentPerformance) {
+documentPerformance->AddEntry(this, this);
+}
+if (mListener) {
+LOG(("  calling OnStopRequest\n"));
+mListener->OnStopRequest(this, mListenerContext, status);
+}
+MOZ_EVENT_TRACER_DONE(this, "net::http::channel");
+CloseCacheEntry(!contentComplete);
+if (mOfflineCacheEntry)
+CloseOfflineCacheEntry();
+if (mLoadGroup)
+mLoadGroup->RemoveRequest(this, nullptr, status);
+// We don't need this info anymore
+CleanRedirectCacheChainIfNecessary();
+ReleaseListeners();
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsIStreamListener
+//-----------------------------------------------------------------------------
+class OnTransportStatusAsyncEvent : public nsRunnable
+{
+public:
+OnTransportStatusAsyncEvent(nsITransportEventSink* aEventSink,
+nsresult aTransportStatus,
+uint64_t aProgress,
+uint64_t aProgressMax)
+: mEventSink(aEventSink)
+, mTransportStatus(aTransportStatus)
+, mProgress(aProgress)
+, mProgressMax(aProgressMax)
+{
+MOZ_ASSERT(!NS_IsMainThread(), "Shouldn't be created on main thread");
+}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(NS_IsMainThread(), "Should run on main thread");
+if (mEventSink) {
+mEventSink->OnTransportStatus(nullptr, mTransportStatus,
+mProgress, mProgressMax);
+}
+return NS_OK;
+}
+private:
+nsCOMPtr<nsITransportEventSink> mEventSink;
+nsresult mTransportStatus;
+uint64_t mProgress;
+uint64_t mProgressMax;
+};
+NS_IMETHODIMP
+nsHttpChannel::OnDataAvailable(nsIRequest *request, nsISupports *ctxt,
+nsIInputStream *input,
+uint64_t offset, uint32_t count)
+{
+PROFILER_LABEL("network", "nsHttpChannel::OnDataAvailable");
+LOG(("nsHttpChannel::OnDataAvailable [this=%p request=%p offset=%llu count=%u]\n",
+this, request, offset, count));
+// don't send out OnDataAvailable notifications if we've been canceled.
+if (mCanceled)
+return mStatus;
+MOZ_ASSERT(mResponseHead, "No response head in ODA!!");
+MOZ_ASSERT(!(mCachedContentIsPartial && (request == mTransactionPump)),
+"transaction pump not suspended");
+if (mAuthRetryPending || (request == mTransactionPump && mTransactionReplaced)) {
+uint32_t n;
+return input->ReadSegments(NS_DiscardSegment, nullptr, count, &n);
+}
+if (mListener) {
+//
+// synthesize transport progress event.  we do this here since we want
+// to delay OnProgress events until we start streaming data.  this is
+// crucially important since it impacts the lock icon (see bug 240053).
+//
+nsresult transportStatus;
+if (request == mCachePump)
+transportStatus = NS_NET_STATUS_READING;
+else
+transportStatus = NS_NET_STATUS_RECEIVING_FROM;
+// mResponseHead may reference new or cached headers, but either way it
+// holds our best estimate of the total content length.  Even in the case
+// of a byte range request, the content length stored in the cached
+// response headers is what we want to use here.
+uint64_t progressMax(uint64_t(mResponseHead->ContentLength()));
+uint64_t progress = mLogicalOffset + uint64_t(count);
+if (progress > progressMax)
+NS_WARNING("unexpected progress values - "
+"is server exceeding content length?");
+if (NS_IsMainThread()) {
+OnTransportStatus(nullptr, transportStatus, progress, progressMax);
+} else {
+nsresult rv = NS_DispatchToMainThread(
+new OnTransportStatusAsyncEvent(this, transportStatus,
+progress, progressMax));
+NS_ENSURE_SUCCESS(rv, rv);
+}
+//
+// we have to manually keep the logical offset of the stream up-to-date.
+// we cannot depend solely on the offset provided, since we may have
+// already streamed some data from another source (see, for example,
+// OnDoneReadingPartialCacheEntry).
+//
+if (!mLogicalOffset)
+MOZ_EVENT_TRACER_EXEC(this, "net::http::channel");
+int64_t offsetBefore = 0;
+nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(input);
+if (seekable && NS_FAILED(seekable->Tell(&offsetBefore))) {
+seekable = nullptr;
+}
+nsresult rv =  mListener->OnDataAvailable(this,
+mListenerContext,
+input,
+mLogicalOffset,
+count);
+if (NS_SUCCEEDED(rv)) {
+// by contract mListener must read all of "count" bytes, but
+// nsInputStreamPump is tolerant to seekable streams that violate that
+// and it will redeliver incompletely read data. So we need to do
+// the same thing when updating the progress counter to stay in sync.
+int64_t offsetAfter, delta;
+if (seekable && NS_SUCCEEDED(seekable->Tell(&offsetAfter))) {
+delta = offsetAfter - offsetBefore;
+if (delta != count) {
+count = delta;
+NS_WARNING("Listener OnDataAvailable contract violation");
+nsCOMPtr<nsIConsoleService> consoleService =
+do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+nsAutoString message
+(NS_LITERAL_STRING(
+"http channel Listener OnDataAvailable contract violation"));
+if (consoleService) {
+consoleService->LogStringMessage(message.get());
+}
+}
+}
+mLogicalOffset += count;
+}
+return rv;
+}
+return NS_ERROR_ABORT;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsIThreadRetargetableRequest
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::RetargetDeliveryTo(nsIEventTarget* aNewTarget)
+{
+MOZ_ASSERT(NS_IsMainThread(), "Should be called on main thread only");
+NS_ENSURE_ARG(aNewTarget);
+if (aNewTarget == NS_GetCurrentThread()) {
+NS_WARNING("Retargeting delivery to same thread");
+return NS_OK;
+}
+NS_ENSURE_TRUE(mTransactionPump || mCachePump, NS_ERROR_NOT_AVAILABLE);
+nsresult rv = NS_OK;
+// If both cache pump and transaction pump exist, we're probably dealing
+// with partially cached content. So, we must be able to retarget both.
+nsCOMPtr<nsIThreadRetargetableRequest> retargetableCachePump;
+nsCOMPtr<nsIThreadRetargetableRequest> retargetableTransactionPump;
+if (mCachePump) {
+retargetableCachePump = do_QueryObject(mCachePump);
+// nsInputStreamPump should implement this interface.
+MOZ_ASSERT(retargetableCachePump);
+rv = retargetableCachePump->RetargetDeliveryTo(aNewTarget);
+}
+if (NS_SUCCEEDED(rv) && mTransactionPump) {
+retargetableTransactionPump = do_QueryObject(mTransactionPump);
+// nsInputStreamPump should implement this interface.
+MOZ_ASSERT(retargetableTransactionPump);
+rv = retargetableTransactionPump->RetargetDeliveryTo(aNewTarget);
+// If retarget fails for transaction pump, we must restore mCachePump.
+if (NS_FAILED(rv) && retargetableCachePump) {
+nsCOMPtr<nsIThread> mainThread;
+rv = NS_GetMainThread(getter_AddRefs(mainThread));
+NS_ENSURE_SUCCESS(rv, rv);
+rv = retargetableCachePump->RetargetDeliveryTo(mainThread);
+}
+}
+return rv;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsThreadRetargetableStreamListener
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::CheckListenerChain()
+{
+NS_ASSERTION(NS_IsMainThread(), "Should be on main thread!");
+nsresult rv = NS_OK;
+nsCOMPtr<nsIThreadRetargetableStreamListener> retargetableListener =
+do_QueryInterface(mListener, &rv);
+if (retargetableListener) {
+rv = retargetableListener->CheckListenerChain();
+}
+return rv;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsITransportEventSink
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::OnTransportStatus(nsITransport *trans, nsresult status,
+uint64_t progress, uint64_t progressMax)
+{
+MOZ_ASSERT(NS_IsMainThread(), "Should be on main thread only");
+// cache the progress sink so we don't have to query for it each time.
+if (!mProgressSink)
+GetCallback(mProgressSink);
+if (status == NS_NET_STATUS_CONNECTED_TO ||
+status == NS_NET_STATUS_WAITING_FOR) {
+nsCOMPtr<nsISocketTransport> socketTransport =
+do_QueryInterface(trans);
+if (socketTransport) {
+socketTransport->GetSelfAddr(&mSelfAddr);
+socketTransport->GetPeerAddr(&mPeerAddr);
+}
+}
+// block socket status event after Cancel or OnStopRequest has been called.
+if (mProgressSink && NS_SUCCEEDED(mStatus) && mIsPending && !(mLoadFlags & LOAD_BACKGROUND)) {
+LOG(("sending status notification [this=%p status=%x progress=%llu/%llu]\n",
+this, status, progress, progressMax));
+nsAutoCString host;
+mURI->GetHost(host);
+mProgressSink->OnStatus(this, nullptr, status,
+NS_ConvertUTF8toUTF16(host).get());
+if (progress > 0) {
+MOZ_ASSERT(progress <= progressMax, "unexpected progress values");
+// Try to get mProgressSink if it was nulled out during OnStatus.
+if (!mProgressSink) {
+GetCallback(mProgressSink);
+}
+if (mProgressSink) {
+mProgressSink->OnProgress(this, nullptr, progress, progressMax);
+}
+}
+}
+#ifdef DEBUG
+else
+LOG(("skipping status notification [this=%p sink=%p pending=%u background=%x]\n",
+this, mProgressSink.get(), mIsPending, (mLoadFlags & LOAD_BACKGROUND)));
+#endif
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsICacheInfoChannel
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::IsFromCache(bool *value)
+{
+if (!mIsPending)
+return NS_ERROR_NOT_AVAILABLE;
+// return false if reading a partial cache entry; the data isn't entirely
+// from the cache!
+*value = (mCachePump || (mLoadFlags & LOAD_ONLY_IF_MODIFIED)) &&
+mCachedContentIsValid && !mCachedContentIsPartial;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetCacheTokenExpirationTime(uint32_t *_retval)
+{
+NS_ENSURE_ARG_POINTER(_retval);
+if (!mCacheEntry)
+return NS_ERROR_NOT_AVAILABLE;
+return mCacheEntry->GetExpirationTime(_retval);
+}
+NS_IMETHODIMP
+nsHttpChannel::GetCacheTokenCachedCharset(nsACString &_retval)
+{
+nsresult rv;
+if (!mCacheEntry)
+return NS_ERROR_NOT_AVAILABLE;
+nsXPIDLCString cachedCharset;
+rv = mCacheEntry->GetMetaDataElement("charset",
+getter_Copies(cachedCharset));
+if (NS_SUCCEEDED(rv))
+_retval = cachedCharset;
+return rv;
+}
+NS_IMETHODIMP
+nsHttpChannel::SetCacheTokenCachedCharset(const nsACString &aCharset)
+{
+if (!mCacheEntry)
+return NS_ERROR_NOT_AVAILABLE;
+return mCacheEntry->SetMetaDataElement("charset",
+PromiseFlatCString(aCharset).get());
+}
+NS_IMETHODIMP
+nsHttpChannel::GetCacheDomain(nsACString &value)
+{
+value = mCacheDomain;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::SetCacheDomain(const nsACString &value)
+{
+mCacheDomain = value;
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsICachingChannel
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::GetCacheToken(nsISupports **token)
+{
+NS_ENSURE_ARG_POINTER(token);
+if (!mCacheEntry)
+return NS_ERROR_NOT_AVAILABLE;
+return CallQueryInterface(mCacheEntry, token);
+}
+NS_IMETHODIMP
+nsHttpChannel::SetCacheToken(nsISupports *token)
+{
+return NS_ERROR_NOT_IMPLEMENTED;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetOfflineCacheToken(nsISupports **token)
+{
+NS_ENSURE_ARG_POINTER(token);
+if (!mOfflineCacheEntry)
+return NS_ERROR_NOT_AVAILABLE;
+return CallQueryInterface(mOfflineCacheEntry, token);
+}
+NS_IMETHODIMP
+nsHttpChannel::SetOfflineCacheToken(nsISupports *token)
+{
+return NS_ERROR_NOT_IMPLEMENTED;
+}
+class nsHttpChannelCacheKey MOZ_FINAL : public nsISupportsPRUint32,
+public nsISupportsCString
+{
+NS_DECL_ISUPPORTS
+NS_DECL_NSISUPPORTSPRIMITIVE
+NS_FORWARD_NSISUPPORTSPRUINT32(mSupportsPRUint32->)
+// Both interfaces declares toString method with the same signature.
+// Thus we have to delegate only to nsISupportsPRUint32 implementation.
+NS_IMETHOD GetData(nsACString & aData)
+{
+return mSupportsCString->GetData(aData);
+}
+NS_IMETHOD SetData(const nsACString & aData)
+{
+return mSupportsCString->SetData(aData);
+}
+public:
+nsresult SetData(uint32_t aPostID, const nsACString& aKey);
+protected:
+nsCOMPtr<nsISupportsPRUint32> mSupportsPRUint32;
+nsCOMPtr<nsISupportsCString> mSupportsCString;
+};
+NS_IMPL_ADDREF(nsHttpChannelCacheKey)
+NS_IMPL_RELEASE(nsHttpChannelCacheKey)
+NS_INTERFACE_TABLE_HEAD(nsHttpChannelCacheKey)
+NS_INTERFACE_TABLE_BEGIN
+NS_INTERFACE_TABLE_ENTRY_AMBIGUOUS(nsHttpChannelCacheKey,
+nsISupports, nsISupportsPRUint32)
+NS_INTERFACE_TABLE_ENTRY_AMBIGUOUS(nsHttpChannelCacheKey,
+nsISupportsPrimitive, nsISupportsPRUint32)
+NS_INTERFACE_TABLE_ENTRY(nsHttpChannelCacheKey,
+nsISupportsPRUint32)
+NS_INTERFACE_TABLE_ENTRY(nsHttpChannelCacheKey,
+nsISupportsCString)
+NS_INTERFACE_TABLE_END
+NS_INTERFACE_TABLE_TAIL
+NS_IMETHODIMP nsHttpChannelCacheKey::GetType(uint16_t *aType)
+{
+NS_ENSURE_ARG_POINTER(aType);
+*aType = TYPE_PRUINT32;
+return NS_OK;
+}
+nsresult nsHttpChannelCacheKey::SetData(uint32_t aPostID,
+const nsACString& aKey)
+{
+nsresult rv;
+mSupportsCString =
+do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID, &rv);
+if (NS_FAILED(rv)) return rv;
+mSupportsCString->SetData(aKey);
+if (NS_FAILED(rv)) return rv;
+mSupportsPRUint32 =
+do_CreateInstance(NS_SUPPORTS_PRUINT32_CONTRACTID, &rv);
+if (NS_FAILED(rv)) return rv;
+mSupportsPRUint32->SetData(aPostID);
+if (NS_FAILED(rv)) return rv;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetCacheKey(nsISupports **key)
+{
+// mayhemer: TODO - do we need this API?
+nsresult rv;
+NS_ENSURE_ARG_POINTER(key);
+LOG(("nsHttpChannel::GetCacheKey [this=%p]\n", this));
+*key = nullptr;
+nsRefPtr<nsHttpChannelCacheKey> container =
+new nsHttpChannelCacheKey();
+if (!container)
+return NS_ERROR_OUT_OF_MEMORY;
+nsAutoCString cacheKey;
+rv = GenerateCacheKey(mPostID, cacheKey);
+if (NS_FAILED(rv)) return rv;
+rv = container->SetData(mPostID, cacheKey);
+if (NS_FAILED(rv)) return rv;
+return CallQueryInterface(container.get(), key);
+}
+NS_IMETHODIMP
+nsHttpChannel::SetCacheKey(nsISupports *key)
+{
+nsresult rv;
+LOG(("nsHttpChannel::SetCacheKey [this=%p key=%p]\n", this, key));
+ENSURE_CALLED_BEFORE_CONNECT();
+if (!key)
+mPostID = 0;
+else {
+// extract the post id
+nsCOMPtr<nsISupportsPRUint32> container = do_QueryInterface(key, &rv);
+if (NS_FAILED(rv)) return rv;
+rv = container->GetData(&mPostID);
+if (NS_FAILED(rv)) return rv;
+}
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsIResumableChannel
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::ResumeAt(uint64_t aStartPos,
+const nsACString& aEntityID)
+{
+LOG(("nsHttpChannel::ResumeAt [this=%p startPos=%llu id='%s']\n",
+this, aStartPos, PromiseFlatCString(aEntityID).get()));
+mEntityID = aEntityID;
+mStartPos = aStartPos;
+mResuming = true;
+return NS_OK;
+}
+nsresult
+nsHttpChannel::DoAuthRetry(nsAHttpConnection *conn)
+{
+LOG(("nsHttpChannel::DoAuthRetry [this=%p]\n", this));
+MOZ_ASSERT(!mTransaction, "should not have a transaction");
+nsresult rv;
+// toggle mIsPending to allow nsIObserver implementations to modify
+// the request headers (bug 95044).
+mIsPending = false;
+// fetch cookies, and add them to the request header.
+// the server response could have included cookies that must be sent with
+// this authentication attempt (bug 84794).
+// TODO: save cookies from auth response and send them here (bug 572151).
+AddCookiesToRequest();
+// notify "http-on-modify-request" observers
+CallOnModifyRequestObservers();
+mIsPending = true;
+// get rid of the old response headers
+mResponseHead = nullptr;
+// rewind the upload stream
+if (mUploadStream) {
+nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(mUploadStream);
+if (seekable)
+seekable->Seek(nsISeekableStream::NS_SEEK_SET, 0);
+}
+// set sticky connection flag and disable pipelining.
+mCaps |=  NS_HTTP_STICKY_CONNECTION;
+mCaps &= ~NS_HTTP_ALLOW_PIPELINING;
+// and create a new one...
+rv = SetupTransaction();
+if (NS_FAILED(rv)) return rv;
+// transfer ownership of connection to transaction
+if (conn)
+mTransaction->SetConnection(conn);
+rv = gHttpHandler->InitiateTransaction(mTransaction, mPriority);
+if (NS_FAILED(rv)) return rv;
+rv = mTransactionPump->AsyncRead(this, nullptr);
+if (NS_FAILED(rv)) return rv;
+uint32_t suspendCount = mSuspendCount;
+while (suspendCount--)
+mTransactionPump->Suspend();
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsIApplicationCacheChannel
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::GetApplicationCache(nsIApplicationCache **out)
+{
+NS_IF_ADDREF(*out = mApplicationCache);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::SetApplicationCache(nsIApplicationCache *appCache)
+{
+ENSURE_CALLED_BEFORE_CONNECT();
+mApplicationCache = appCache;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetApplicationCacheForWrite(nsIApplicationCache **out)
+{
+NS_IF_ADDREF(*out = mApplicationCacheForWrite);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::SetApplicationCacheForWrite(nsIApplicationCache *appCache)
+{
+ENSURE_CALLED_BEFORE_CONNECT();
+mApplicationCacheForWrite = appCache;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetLoadedFromApplicationCache(bool *aLoadedFromApplicationCache)
+{
+*aLoadedFromApplicationCache = mLoadedFromApplicationCache;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetInheritApplicationCache(bool *aInherit)
+{
+*aInherit = mInheritApplicationCache;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::SetInheritApplicationCache(bool aInherit)
+{
+ENSURE_CALLED_BEFORE_CONNECT();
+mInheritApplicationCache = aInherit;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::GetChooseApplicationCache(bool *aChoose)
+{
+*aChoose = mChooseApplicationCache;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::SetChooseApplicationCache(bool aChoose)
+{
+ENSURE_CALLED_BEFORE_CONNECT();
+mChooseApplicationCache = aChoose;
+return NS_OK;
+}
+nsHttpChannel::OfflineCacheEntryAsForeignMarker*
+nsHttpChannel::GetOfflineCacheEntryAsForeignMarker()
+{
+if (!mApplicationCache)
+return nullptr;
+return new OfflineCacheEntryAsForeignMarker(mApplicationCache, mURI);
+}
+nsresult
+nsHttpChannel::OfflineCacheEntryAsForeignMarker::MarkAsForeign()
+{
+nsresult rv;
+nsCOMPtr<nsIURI> noRefURI;
+rv = mCacheURI->CloneIgnoringRef(getter_AddRefs(noRefURI));
+NS_ENSURE_SUCCESS(rv, rv);
+nsAutoCString spec;
+rv = noRefURI->GetAsciiSpec(spec);
+NS_ENSURE_SUCCESS(rv, rv);
+return mApplicationCache->MarkEntry(spec,
+nsIApplicationCache::ITEM_FOREIGN);
+}
+NS_IMETHODIMP
+nsHttpChannel::MarkOfflineCacheEntryAsForeign()
+{
+nsresult rv;
+nsAutoPtr<OfflineCacheEntryAsForeignMarker> marker(
+GetOfflineCacheEntryAsForeignMarker());
+if (!marker)
+return NS_ERROR_NOT_AVAILABLE;
+rv = marker->MarkAsForeign();
+NS_ENSURE_SUCCESS(rv, rv);
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel::nsIAsyncVerifyRedirectCallback
+//-----------------------------------------------------------------------------
+nsresult
+nsHttpChannel::WaitForRedirectCallback()
+{
+nsresult rv;
+LOG(("nsHttpChannel::WaitForRedirectCallback [this=%p]\n", this));
+if (mTransactionPump) {
+rv = mTransactionPump->Suspend();
+NS_ENSURE_SUCCESS(rv, rv);
+}
+if (mCachePump) {
+rv = mCachePump->Suspend();
+if (NS_FAILED(rv) && mTransactionPump) {
+#ifdef DEBUG
+nsresult resume =
+#endif
+mTransactionPump->Resume();
+MOZ_ASSERT(NS_SUCCEEDED(resume),
+"Failed to resume transaction pump");
+}
+NS_ENSURE_SUCCESS(rv, rv);
+}
+mWaitingForRedirectCallback = true;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsHttpChannel::OnRedirectVerifyCallback(nsresult result)
+{
+LOG(("nsHttpChannel::OnRedirectVerifyCallback [this=%p] "
+"result=%x stack=%d mWaitingForRedirectCallback=%u\n",
+this, result, mRedirectFuncStack.Length(), mWaitingForRedirectCallback));
+MOZ_ASSERT(mWaitingForRedirectCallback,
+"Someone forgot to call WaitForRedirectCallback() ?!");
+mWaitingForRedirectCallback = false;
+if (mCanceled && NS_SUCCEEDED(result))
+result = NS_BINDING_ABORTED;
+for (uint32_t i = mRedirectFuncStack.Length(); i > 0;) {
+--i;
+// Pop the last function pushed to the stack
+nsContinueRedirectionFunc func = mRedirectFuncStack[i];
+mRedirectFuncStack.RemoveElementAt(mRedirectFuncStack.Length() - 1);
+// Call it with the result we got from the callback or the deeper
+// function call.
+result = (this->*func)(result);
+// If a new function has been pushed to the stack and placed us in the
+// waiting state, we need to break the chain and wait for the callback
+// again.
+if (mWaitingForRedirectCallback)
+break;
+}
+if (NS_FAILED(result) && !mCanceled) {
+// First, cancel this channel if we are in failure state to set mStatus
+// and let it be propagated to pumps.
+Cancel(result);
+}
+if (!mWaitingForRedirectCallback) {
+// We are not waiting for the callback. At this moment we must release
+// reference to the redirect target channel, otherwise we may leak.
+mRedirectChannel = nullptr;
+MOZ_EVENT_TRACER_DONE(this, "net::http::channel");
+}
+// We always resume the pumps here. If all functions on stack have been
+// called we need OnStopRequest to be triggered, and if we broke out of the
+// loop above (and are thus waiting for a new callback) the suspension
+// count must be balanced in the pumps.
+if (mTransactionPump)
+mTransactionPump->Resume();
+if (mCachePump)
+mCachePump->Resume();
+return result;
+}
+void
+nsHttpChannel::PushRedirectAsyncFunc(nsContinueRedirectionFunc func)
+{
+mRedirectFuncStack.AppendElement(func);
+}
+void
+nsHttpChannel::PopRedirectAsyncFunc(nsContinueRedirectionFunc func)
+{
+MOZ_ASSERT(func == mRedirectFuncStack[mRedirectFuncStack.Length() - 1],
+"Trying to pop wrong method from redirect async stack!");
+mRedirectFuncStack.TruncateLength(mRedirectFuncStack.Length() - 1);
+}
+//-----------------------------------------------------------------------------
+// nsIDNSListener functions
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpChannel::OnLookupComplete(nsICancelable *request,
+nsIDNSRecord  *rec,
+nsresult       status)
+{
+MOZ_ASSERT(NS_IsMainThread(), "Expecting DNS callback on main thread.");
+LOG(("nsHttpChannel::OnLookupComplete [this=%p] prefetch complete%s: "
+"%s status[0x%x]\n",
+this, mCaps & NS_HTTP_REFRESH_DNS ? ", refresh requested" : "",
+NS_SUCCEEDED(status) ? "success" : "failure", status));
+// We no longer need the dns prefetch object. Note: mDNSPrefetch could be
+// validly null if OnStopRequest has already been called.
+if (mDNSPrefetch && mDNSPrefetch->TimingsValid()) {
+mTransactionTimings.domainLookupStart =
+mDNSPrefetch->StartTimestamp();
+mTransactionTimings.domainLookupEnd =
+mDNSPrefetch->EndTimestamp();
+}
+mDNSPrefetch = nullptr;
+// Unset DNS cache refresh if it was requested,
+if (mCaps & NS_HTTP_REFRESH_DNS) {
+mCaps &= ~NS_HTTP_REFRESH_DNS;
+if (mTransaction) {
+mTransaction->SetDNSWasRefreshed();
+}
+}
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsHttpChannel internal functions
+//-----------------------------------------------------------------------------
+void
+nsHttpChannel::MaybeInvalidateCacheEntryForSubsequentGet()
+{
+// See RFC 2616 section 5.1.1. These are considered valid
+// methods which DO NOT invalidate cache-entries for the
+// referred resource. POST, PUT and DELETE as well as any
+// other method not listed here will potentially invalidate
+// any cached copy of the resource
+if (mRequestHead.IsGet() || mRequestHead.IsOptions() ||
+mRequestHead.IsHead() || mRequestHead.IsTrace() ||
+mRequestHead.IsConnect()) {
+return;
+}
+// Invalidate the request-uri.
+#ifdef PR_LOGGING
+nsAutoCString key;
+mURI->GetAsciiSpec(key);
+LOG(("MaybeInvalidateCacheEntryForSubsequentGet [this=%p uri=%s]\n",
+this, key.get()));
+#endif
+DoInvalidateCacheEntry(mURI);
+// Invalidate Location-header if set
+const char *location = mResponseHead->PeekHeader(nsHttp::Location);
+if (location) {
+LOG(("  Location-header=%s\n", location));
+InvalidateCacheEntryForLocation(location);
+}
+// Invalidate Content-Location-header if set
+location = mResponseHead->PeekHeader(nsHttp::Content_Location);
+if (location) {
+LOG(("  Content-Location-header=%s\n", location));
+InvalidateCacheEntryForLocation(location);
+}
+}
+void
+nsHttpChannel::InvalidateCacheEntryForLocation(const char *location)
+{
+nsAutoCString tmpCacheKey, tmpSpec;
+nsCOMPtr<nsIURI> resultingURI;
+nsresult rv = CreateNewURI(location, getter_AddRefs(resultingURI));
+if (NS_SUCCEEDED(rv) && HostPartIsTheSame(resultingURI)) {
+DoInvalidateCacheEntry(resultingURI);
+} else {
+LOG(("  hosts not matching\n"));
+}
+}
+void
+nsHttpChannel::DoInvalidateCacheEntry(nsIURI* aURI)
+{
+// NOTE:
+// Following comments 24,32 and 33 in bug #327765, we only care about
+// the cache in the protocol-handler, not the application cache.
+// The logic below deviates from the original logic in OpenCacheEntry on
+// one point by using only READ_ONLY access-policy. I think this is safe.
+nsresult rv;
+#ifdef PR_LOGGING
+nsAutoCString key;
+aURI->GetAsciiSpec(key);
+LOG(("DoInvalidateCacheEntry [channel=%p key=%s]", this, key.get()));
+#endif
+nsCOMPtr<nsICacheStorageService> cacheStorageService =
+do_GetService("@mozilla.org/netwerk/cache-storage-service;1", &rv);
+nsCOMPtr<nsICacheStorage> cacheStorage;
+if (NS_SUCCEEDED(rv)) {
+nsRefPtr<LoadContextInfo> info = GetLoadContextInfo(this);
+rv = cacheStorageService->DiskCacheStorage(info, false, getter_AddRefs(cacheStorage));
+}
+if (NS_SUCCEEDED(rv)) {
+rv = cacheStorage->AsyncDoomURI(aURI, EmptyCString(), nullptr);
+}
+LOG(("DoInvalidateCacheEntry [channel=%p key=%s rv=%d]", this, key.get(), int(rv)));
+}
+void
+nsHttpChannel::AsyncOnExamineCachedResponse()
+{
+gHttpHandler->OnExamineCachedResponse(this);
+}
+void
+nsHttpChannel::UpdateAggregateCallbacks()
+{
+if (!mTransaction) {
+return;
+}
+nsCOMPtr<nsIInterfaceRequestor> callbacks;
+NS_NewNotificationCallbacksAggregation(mCallbacks, mLoadGroup,
+NS_GetCurrentThread(),
+getter_AddRefs(callbacks));
+mTransaction->SetSecurityCallbacks(callbacks);
+}
+nsIPrincipal *
+nsHttpChannel::GetPrincipal()
+{
+if (mPrincipal)
+return mPrincipal;
+nsIScriptSecurityManager *securityManager =
+nsContentUtils::GetSecurityManager();
+if (!securityManager)
+return nullptr;
+securityManager->GetChannelPrincipal(this, getter_AddRefs(mPrincipal));
+if (!mPrincipal)
+return nullptr;
+// principals with unknown app ids do not work with the permission manager
+if (mPrincipal->GetUnknownAppId())
+mPrincipal = nullptr;
+return mPrincipal;
+}
+NS_IMETHODIMP
+nsHttpChannel::SetLoadGroup(nsILoadGroup *aLoadGroup)
+{
+MOZ_ASSERT(NS_IsMainThread(), "Wrong thread.");
+nsresult rv = HttpBaseChannel::SetLoadGroup(aLoadGroup);
+if (NS_SUCCEEDED(rv)) {
+UpdateAggregateCallbacks();
+}
+return rv;
+}
+NS_IMETHODIMP
+nsHttpChannel::SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks)
+{
+MOZ_ASSERT(NS_IsMainThread(), "Wrong thread.");
+nsresult rv = HttpBaseChannel::SetNotificationCallbacks(aCallbacks);
+if (NS_SUCCEEDED(rv)) {
+UpdateAggregateCallbacks();
+}
+return rv;
+}
+nsPerformance*
+nsHttpChannel::GetPerformance()
+{
+// If performance timing is disabled, there is no need for the nsPerformance
+// object anymore.
+if (!mTimingEnabled) {
+return nullptr;
+}
+nsCOMPtr<nsILoadContext> loadContext;
+NS_QueryNotificationCallbacks(this, loadContext);
+if (!loadContext) {
+return nullptr;
+}
+nsCOMPtr<nsIDOMWindow> domWindow;
+loadContext->GetAssociatedWindow(getter_AddRefs(domWindow));
+if (!domWindow) {
+return nullptr;
+}
+nsCOMPtr<nsPIDOMWindow> pDomWindow = do_QueryInterface(domWindow);
+if (!pDomWindow) {
+return nullptr;
+}
+if (!pDomWindow->IsInnerWindow()) {
+pDomWindow = pDomWindow->GetCurrentInnerWindow();
+if (!pDomWindow) {
+return nullptr;
+}
+}
+nsPerformance* docPerformance = pDomWindow->GetPerformance();
+if (!docPerformance) {
+return nullptr;
+}
+// iframes should be added to the parent's entries list.
+if (mLoadFlags & LOAD_DOCUMENT_URI) {
+return docPerformance->GetParentPerformance();
+}
+return docPerformance;
+}
+void
+nsHttpChannel::ForcePending(bool aForcePending)
+{
+// Set true here so IsPending will return true.
+// Required for callback diversion from child back to parent. In such cases
+// OnStopRequest can be called in the parent before callbacks are diverted
+// back from the child to the listener in the parent.
+mForcePending = aForcePending;
+}
+NS_IMETHODIMP
+nsHttpChannel::IsPending(bool *aIsPending)
+{
+NS_ENSURE_ARG_POINTER(aIsPending);
+*aIsPending = mIsPending || mForcePending;
+return NS_OK;
+}
+} } // namespace mozilla::net

The Tor Browser / file comparison

comparison: netwerk/protocol/http/nsHttpChannel.cpp

netwerk/protocol/http/nsHttpChannel.cpp