diff options
Diffstat (limited to 'image/imgLoader.cpp')
| -rw-r--r-- | image/imgLoader.cpp | 2993 |
1 files changed, 2993 insertions, 0 deletions
diff --git a/image/imgLoader.cpp b/image/imgLoader.cpp new file mode 100644 index 000000000..3545c5be2 --- /dev/null +++ b/image/imgLoader.cpp @@ -0,0 +1,2993 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ImageLogging.h" +#include "imgLoader.h" + +#include "mozilla/Attributes.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/Move.h" +#include "mozilla/Preferences.h" +#include "mozilla/ChaosMode.h" + +#include "nsImageModule.h" +#include "imgRequestProxy.h" + +#include "nsCOMPtr.h" + +#include "nsContentPolicyUtils.h" +#include "nsContentUtils.h" +#include "nsNetUtil.h" +#include "nsNetCID.h" +#include "nsIProtocolHandler.h" +#include "nsMimeTypes.h" +#include "nsStreamUtils.h" +#include "nsIHttpChannel.h" +#include "nsICacheInfoChannel.h" +#include "nsIInterfaceRequestor.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsIProgressEventSink.h" +#include "nsIChannelEventSink.h" +#include "nsIAsyncVerifyRedirectCallback.h" +#include "nsIFileURL.h" +#include "nsIFile.h" +#include "nsCRT.h" +#include "nsINetworkPredictor.h" +#include "mozilla/dom/ContentParent.h" +#include "mozilla/dom/nsMixedContentBlocker.h" + +#include "nsIApplicationCache.h" +#include "nsIApplicationCacheContainer.h" + +#include "nsIMemoryReporter.h" +#include "DecoderFactory.h" +#include "Image.h" +#include "gfxPrefs.h" +#include "prtime.h" + +// we want to explore making the document own the load group +// so we can associate the document URI with the load group. +// until this point, we have an evil hack: +#include "nsIHttpChannelInternal.h" +#include "nsILoadContext.h" +#include "nsILoadGroupChild.h" +#include "nsIDOMDocument.h" + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::image; +using namespace mozilla::net; + +MOZ_DEFINE_MALLOC_SIZE_OF(ImagesMallocSizeOf) + +class imgMemoryReporter final : public nsIMemoryReporter +{ + ~imgMemoryReporter() { } + +public: + NS_DECL_ISUPPORTS + + NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, bool aAnonymize) override + { + nsTArray<ImageMemoryCounter> chrome; + nsTArray<ImageMemoryCounter> content; + nsTArray<ImageMemoryCounter> uncached; + + for (uint32_t i = 0; i < mKnownLoaders.Length(); i++) { + for (auto iter = mKnownLoaders[i]->mChromeCache.Iter(); !iter.Done(); iter.Next()) { + imgCacheEntry* entry = iter.UserData(); + RefPtr<imgRequest> req = entry->GetRequest(); + RecordCounterForRequest(req, &chrome, !entry->HasNoProxies()); + } + for (auto iter = mKnownLoaders[i]->mCache.Iter(); !iter.Done(); iter.Next()) { + imgCacheEntry* entry = iter.UserData(); + RefPtr<imgRequest> req = entry->GetRequest(); + RecordCounterForRequest(req, &content, !entry->HasNoProxies()); + } + MutexAutoLock lock(mKnownLoaders[i]->mUncachedImagesMutex); + for (auto iter = mKnownLoaders[i]->mUncachedImages.Iter(); + !iter.Done(); + iter.Next()) { + nsPtrHashKey<imgRequest>* entry = iter.Get(); + RefPtr<imgRequest> req = entry->GetKey(); + RecordCounterForRequest(req, &uncached, req->HasConsumers()); + } + } + + // Note that we only need to anonymize content image URIs. + + ReportCounterArray(aHandleReport, aData, chrome, "images/chrome"); + + ReportCounterArray(aHandleReport, aData, content, "images/content", + aAnonymize); + + // Uncached images may be content or chrome, so anonymize them. + ReportCounterArray(aHandleReport, aData, uncached, "images/uncached", + aAnonymize); + + return NS_OK; + } + + static int64_t ImagesContentUsedUncompressedDistinguishedAmount() + { + size_t n = 0; + for (uint32_t i = 0; i < imgLoader::sMemReporter->mKnownLoaders.Length(); + i++) { + for (auto iter = imgLoader::sMemReporter->mKnownLoaders[i]->mCache.Iter(); + !iter.Done(); + iter.Next()) { + imgCacheEntry* entry = iter.UserData(); + if (entry->HasNoProxies()) { + continue; + } + + RefPtr<imgRequest> req = entry->GetRequest(); + RefPtr<Image> image = req->GetImage(); + if (!image) { + continue; + } + + // Both this and EntryImageSizes measure images/content/raster/used/decoded + // memory. This function's measurement is secondary -- the result doesn't + // go in the "explicit" tree -- so we use moz_malloc_size_of instead of + // ImagesMallocSizeOf to prevent DMD from seeing it reported twice. + ImageMemoryCounter counter(image, moz_malloc_size_of, /* aIsUsed = */ true); + + n += counter.Values().DecodedHeap(); + n += counter.Values().DecodedNonHeap(); + } + } + return n; + } + + void RegisterLoader(imgLoader* aLoader) + { + mKnownLoaders.AppendElement(aLoader); + } + + void UnregisterLoader(imgLoader* aLoader) + { + mKnownLoaders.RemoveElement(aLoader); + } + +private: + nsTArray<imgLoader*> mKnownLoaders; + + struct MemoryTotal + { + MemoryTotal& operator+=(const ImageMemoryCounter& aImageCounter) + { + if (aImageCounter.Type() == imgIContainer::TYPE_RASTER) { + if (aImageCounter.IsUsed()) { + mUsedRasterCounter += aImageCounter.Values(); + } else { + mUnusedRasterCounter += aImageCounter.Values(); + } + } else if (aImageCounter.Type() == imgIContainer::TYPE_VECTOR) { + if (aImageCounter.IsUsed()) { + mUsedVectorCounter += aImageCounter.Values(); + } else { + mUnusedVectorCounter += aImageCounter.Values(); + } + } else { + MOZ_CRASH("Unexpected image type"); + } + + return *this; + } + + const MemoryCounter& UsedRaster() const { return mUsedRasterCounter; } + const MemoryCounter& UnusedRaster() const { return mUnusedRasterCounter; } + const MemoryCounter& UsedVector() const { return mUsedVectorCounter; } + const MemoryCounter& UnusedVector() const { return mUnusedVectorCounter; } + + private: + MemoryCounter mUsedRasterCounter; + MemoryCounter mUnusedRasterCounter; + MemoryCounter mUsedVectorCounter; + MemoryCounter mUnusedVectorCounter; + }; + + // Reports all images of a single kind, e.g. all used chrome images. + void ReportCounterArray(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, + nsTArray<ImageMemoryCounter>& aCounterArray, + const char* aPathPrefix, + bool aAnonymize = false) + { + MemoryTotal summaryTotal; + MemoryTotal nonNotableTotal; + + // Report notable images, and compute total and non-notable aggregate sizes. + for (uint32_t i = 0; i < aCounterArray.Length(); i++) { + ImageMemoryCounter& counter = aCounterArray[i]; + + if (aAnonymize) { + counter.URI().Truncate(); + counter.URI().AppendPrintf("<anonymized-%u>", i); + } else { + // The URI could be an extremely long data: URI. Truncate if needed. + static const size_t max = 256; + if (counter.URI().Length() > max) { + counter.URI().Truncate(max); + counter.URI().AppendLiteral(" (truncated)"); + } + counter.URI().ReplaceChar('/', '\\'); + } + + summaryTotal += counter; + + if (counter.IsNotable()) { + ReportImage(aHandleReport, aData, aPathPrefix, counter); + } else { + nonNotableTotal += counter; + } + } + + // Report non-notable images in aggregate. + ReportTotal(aHandleReport, aData, /* aExplicit = */ true, + aPathPrefix, "<non-notable images>/", nonNotableTotal); + + // Report a summary in aggregate, outside of the explicit tree. + ReportTotal(aHandleReport, aData, /* aExplicit = */ false, + aPathPrefix, "", summaryTotal); + } + + static void ReportImage(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, + const char* aPathPrefix, + const ImageMemoryCounter& aCounter) + { + nsAutoCString pathPrefix(NS_LITERAL_CSTRING("explicit/")); + pathPrefix.Append(aPathPrefix); + pathPrefix.Append(aCounter.Type() == imgIContainer::TYPE_RASTER + ? "/raster/" + : "/vector/"); + pathPrefix.Append(aCounter.IsUsed() ? "used/" : "unused/"); + pathPrefix.Append("image("); + pathPrefix.AppendInt(aCounter.IntrinsicSize().width); + pathPrefix.Append("x"); + pathPrefix.AppendInt(aCounter.IntrinsicSize().height); + pathPrefix.Append(", "); + + if (aCounter.URI().IsEmpty()) { + pathPrefix.Append("<unknown URI>"); + } else { + pathPrefix.Append(aCounter.URI()); + } + + pathPrefix.Append(")/"); + + ReportSurfaces(aHandleReport, aData, pathPrefix, aCounter); + + ReportSourceValue(aHandleReport, aData, pathPrefix, aCounter.Values()); + } + + static void ReportSurfaces(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, + const nsACString& aPathPrefix, + const ImageMemoryCounter& aCounter) + { + for (const SurfaceMemoryCounter& counter : aCounter.Surfaces()) { + nsAutoCString surfacePathPrefix(aPathPrefix); + surfacePathPrefix.Append(counter.IsLocked() ? "locked/" : "unlocked/"); + surfacePathPrefix.Append("surface("); + surfacePathPrefix.AppendInt(counter.Key().Size().width); + surfacePathPrefix.Append("x"); + surfacePathPrefix.AppendInt(counter.Key().Size().height); + + if (counter.Type() == SurfaceMemoryCounterType::NORMAL) { + PlaybackType playback = counter.Key().Playback(); + surfacePathPrefix.Append(playback == PlaybackType::eAnimated + ? " (animation)" + : ""); + + if (counter.Key().Flags() != DefaultSurfaceFlags()) { + surfacePathPrefix.Append(", flags:"); + surfacePathPrefix.AppendInt(uint32_t(counter.Key().Flags()), + /* aRadix = */ 16); + } + } else if (counter.Type() == SurfaceMemoryCounterType::COMPOSITING) { + surfacePathPrefix.Append(", compositing frame"); + } else if (counter.Type() == SurfaceMemoryCounterType::COMPOSITING_PREV) { + surfacePathPrefix.Append(", compositing prev frame"); + } else { + MOZ_ASSERT_UNREACHABLE("Unknown counter type"); + } + + surfacePathPrefix.Append(")/"); + + ReportValues(aHandleReport, aData, surfacePathPrefix, counter.Values()); + } + } + + static void ReportTotal(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, + bool aExplicit, + const char* aPathPrefix, + const char* aPathInfix, + const MemoryTotal& aTotal) + { + nsAutoCString pathPrefix; + if (aExplicit) { + pathPrefix.Append("explicit/"); + } + pathPrefix.Append(aPathPrefix); + + nsAutoCString rasterUsedPrefix(pathPrefix); + rasterUsedPrefix.Append("/raster/used/"); + rasterUsedPrefix.Append(aPathInfix); + ReportValues(aHandleReport, aData, rasterUsedPrefix, aTotal.UsedRaster()); + + nsAutoCString rasterUnusedPrefix(pathPrefix); + rasterUnusedPrefix.Append("/raster/unused/"); + rasterUnusedPrefix.Append(aPathInfix); + ReportValues(aHandleReport, aData, rasterUnusedPrefix, + aTotal.UnusedRaster()); + + nsAutoCString vectorUsedPrefix(pathPrefix); + vectorUsedPrefix.Append("/vector/used/"); + vectorUsedPrefix.Append(aPathInfix); + ReportValues(aHandleReport, aData, vectorUsedPrefix, aTotal.UsedVector()); + + nsAutoCString vectorUnusedPrefix(pathPrefix); + vectorUnusedPrefix.Append("/vector/unused/"); + vectorUnusedPrefix.Append(aPathInfix); + ReportValues(aHandleReport, aData, vectorUnusedPrefix, + aTotal.UnusedVector()); + } + + static void ReportValues(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, + const nsACString& aPathPrefix, + const MemoryCounter& aCounter) + { + ReportSourceValue(aHandleReport, aData, aPathPrefix, aCounter); + + ReportValue(aHandleReport, aData, KIND_HEAP, aPathPrefix, + "decoded-heap", + "Decoded image data which is stored on the heap.", + aCounter.DecodedHeap()); + + ReportValue(aHandleReport, aData, KIND_NONHEAP, aPathPrefix, + "decoded-nonheap", + "Decoded image data which isn't stored on the heap.", + aCounter.DecodedNonHeap()); + } + + static void ReportSourceValue(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, + const nsACString& aPathPrefix, + const MemoryCounter& aCounter) + { + ReportValue(aHandleReport, aData, KIND_HEAP, aPathPrefix, + "source", + "Raster image source data and vector image documents.", + aCounter.Source()); + } + + static void ReportValue(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, + int32_t aKind, + const nsACString& aPathPrefix, + const char* aPathSuffix, + const char* aDescription, + size_t aValue) + { + if (aValue == 0) { + return; + } + + nsAutoCString desc(aDescription); + nsAutoCString path(aPathPrefix); + path.Append(aPathSuffix); + + aHandleReport->Callback(EmptyCString(), path, aKind, UNITS_BYTES, + aValue, desc, aData); + } + + static void RecordCounterForRequest(imgRequest* aRequest, + nsTArray<ImageMemoryCounter>* aArray, + bool aIsUsed) + { + RefPtr<Image> image = aRequest->GetImage(); + if (!image) { + return; + } + + ImageMemoryCounter counter(image, ImagesMallocSizeOf, aIsUsed); + + aArray->AppendElement(Move(counter)); + } +}; + +NS_IMPL_ISUPPORTS(imgMemoryReporter, nsIMemoryReporter) + +NS_IMPL_ISUPPORTS(nsProgressNotificationProxy, + nsIProgressEventSink, + nsIChannelEventSink, + nsIInterfaceRequestor) + +NS_IMETHODIMP +nsProgressNotificationProxy::OnProgress(nsIRequest* request, + nsISupports* ctxt, + int64_t progress, + int64_t progressMax) +{ + nsCOMPtr<nsILoadGroup> loadGroup; + request->GetLoadGroup(getter_AddRefs(loadGroup)); + + nsCOMPtr<nsIProgressEventSink> target; + NS_QueryNotificationCallbacks(mOriginalCallbacks, + loadGroup, + NS_GET_IID(nsIProgressEventSink), + getter_AddRefs(target)); + if (!target) { + return NS_OK; + } + return target->OnProgress(mImageRequest, ctxt, progress, progressMax); +} + +NS_IMETHODIMP +nsProgressNotificationProxy::OnStatus(nsIRequest* request, + nsISupports* ctxt, + nsresult status, + const char16_t* statusArg) +{ + nsCOMPtr<nsILoadGroup> loadGroup; + request->GetLoadGroup(getter_AddRefs(loadGroup)); + + nsCOMPtr<nsIProgressEventSink> target; + NS_QueryNotificationCallbacks(mOriginalCallbacks, + loadGroup, + NS_GET_IID(nsIProgressEventSink), + getter_AddRefs(target)); + if (!target) { + return NS_OK; + } + return target->OnStatus(mImageRequest, ctxt, status, statusArg); +} + +NS_IMETHODIMP +nsProgressNotificationProxy:: + AsyncOnChannelRedirect(nsIChannel* oldChannel, + nsIChannel* newChannel, + uint32_t flags, + nsIAsyncVerifyRedirectCallback* cb) +{ + // Tell the original original callbacks about it too + nsCOMPtr<nsILoadGroup> loadGroup; + newChannel->GetLoadGroup(getter_AddRefs(loadGroup)); + nsCOMPtr<nsIChannelEventSink> target; + NS_QueryNotificationCallbacks(mOriginalCallbacks, + loadGroup, + NS_GET_IID(nsIChannelEventSink), + getter_AddRefs(target)); + if (!target) { + cb->OnRedirectVerifyCallback(NS_OK); + return NS_OK; + } + + // Delegate to |target| if set, reusing |cb| + return target->AsyncOnChannelRedirect(oldChannel, newChannel, flags, cb); +} + +NS_IMETHODIMP +nsProgressNotificationProxy::GetInterface(const nsIID& iid, + void** result) +{ + if (iid.Equals(NS_GET_IID(nsIProgressEventSink))) { + *result = static_cast<nsIProgressEventSink*>(this); + NS_ADDREF_THIS(); + return NS_OK; + } + if (iid.Equals(NS_GET_IID(nsIChannelEventSink))) { + *result = static_cast<nsIChannelEventSink*>(this); + NS_ADDREF_THIS(); + return NS_OK; + } + if (mOriginalCallbacks) { + return mOriginalCallbacks->GetInterface(iid, result); + } + return NS_NOINTERFACE; +} + +static void +NewRequestAndEntry(bool aForcePrincipalCheckForCacheEntry, imgLoader* aLoader, + const ImageCacheKey& aKey, + imgRequest** aRequest, imgCacheEntry** aEntry) +{ + RefPtr<imgRequest> request = new imgRequest(aLoader, aKey); + RefPtr<imgCacheEntry> entry = + new imgCacheEntry(aLoader, request, aForcePrincipalCheckForCacheEntry); + aLoader->AddToUncachedImages(request); + request.forget(aRequest); + entry.forget(aEntry); +} + +static bool +ShouldRevalidateEntry(imgCacheEntry* aEntry, + nsLoadFlags aFlags, + bool aHasExpired) +{ + bool bValidateEntry = false; + + if (aFlags & nsIRequest::LOAD_BYPASS_CACHE) { + return false; + } + + if (aFlags & nsIRequest::VALIDATE_ALWAYS) { + bValidateEntry = true; + } else if (aEntry->GetMustValidate()) { + bValidateEntry = true; + } else if (aHasExpired) { + // The cache entry has expired... Determine whether the stale cache + // entry can be used without validation... + if (aFlags & (nsIRequest::VALIDATE_NEVER | + nsIRequest::VALIDATE_ONCE_PER_SESSION)) { + // VALIDATE_NEVER and VALIDATE_ONCE_PER_SESSION allow stale cache + // entries to be used unless they have been explicitly marked to + // indicate that revalidation is necessary. + bValidateEntry = false; + + } else if (!(aFlags & nsIRequest::LOAD_FROM_CACHE)) { + // LOAD_FROM_CACHE allows a stale cache entry to be used... Otherwise, + // the entry must be revalidated. + bValidateEntry = true; + } + } + + return bValidateEntry; +} + +/* Call content policies on cached images that went through a redirect */ +static bool +ShouldLoadCachedImage(imgRequest* aImgRequest, + nsISupports* aLoadingContext, + nsIPrincipal* aLoadingPrincipal, + nsContentPolicyType aPolicyType) +{ + /* Call content policies on cached images - Bug 1082837 + * Cached images are keyed off of the first uri in a redirect chain. + * Hence content policies don't get a chance to test the intermediate hops + * or the final desitnation. Here we test the final destination using + * mCurrentURI off of the imgRequest and passing it into content policies. + * For Mixed Content Blocker, we do an additional check to determine if any + * of the intermediary hops went through an insecure redirect with the + * mHadInsecureRedirect flag + */ + bool insecureRedirect = aImgRequest->HadInsecureRedirect(); + nsCOMPtr<nsIURI> contentLocation; + aImgRequest->GetCurrentURI(getter_AddRefs(contentLocation)); + nsresult rv; + + int16_t decision = nsIContentPolicy::REJECT_REQUEST; + rv = NS_CheckContentLoadPolicy(aPolicyType, + contentLocation, + aLoadingPrincipal, + aLoadingContext, + EmptyCString(), //mime guess + nullptr, //aExtra + &decision, + nsContentUtils::GetContentPolicy(), + nsContentUtils::GetSecurityManager()); + if (NS_FAILED(rv) || !NS_CP_ACCEPTED(decision)) { + return false; + } + + // We call all Content Policies above, but we also have to call mcb + // individually to check the intermediary redirect hops are secure. + if (insecureRedirect) { + if (!nsContentUtils::IsSystemPrincipal(aLoadingPrincipal)) { + // Set the requestingLocation from the aLoadingPrincipal. + nsCOMPtr<nsIURI> requestingLocation; + if (aLoadingPrincipal) { + rv = aLoadingPrincipal->GetURI(getter_AddRefs(requestingLocation)); + NS_ENSURE_SUCCESS(rv, false); + } + + // reset the decision for mixed content blocker check + decision = nsIContentPolicy::REJECT_REQUEST; + rv = nsMixedContentBlocker::ShouldLoad(insecureRedirect, + aPolicyType, + contentLocation, + requestingLocation, + aLoadingContext, + EmptyCString(), //mime guess + nullptr, + aLoadingPrincipal, + &decision); + if (NS_FAILED(rv) || !NS_CP_ACCEPTED(decision)) { + return false; + } + } + } + + bool sendPriming = false; + bool mixedContentWouldBlock = false; + rv = nsMixedContentBlocker::GetHSTSPrimingFromRequestingContext(contentLocation, + aLoadingContext, &sendPriming, &mixedContentWouldBlock); + if (NS_FAILED(rv)) { + return false; + } + if (sendPriming && mixedContentWouldBlock) { + // if either of the securty checks above would cause a priming request, we + // can't load this image from the cache, so go ahead and return false here + return false; + } + + return true; +} + +// Returns true if this request is compatible with the given CORS mode on the +// given loading principal, and false if the request may not be reused due +// to CORS. Also checks the Referrer Policy, since requests with different +// referrers/policies may generate different responses. +static bool +ValidateSecurityInfo(imgRequest* request, bool forcePrincipalCheck, + int32_t corsmode, nsIPrincipal* loadingPrincipal, + nsISupports* aCX, nsContentPolicyType aPolicyType, + ReferrerPolicy referrerPolicy) +{ + // If the entry's Referrer Policy doesn't match, we can't use this request. + // XXX: this will return false if an image has different referrer attributes, + // i.e. we currently don't use the cached image but reload the image with + // the new referrer policy bug 1174921 + if (referrerPolicy != request->GetReferrerPolicy()) { + return false; + } + + // If the entry's CORS mode doesn't match, or the CORS mode matches but the + // document principal isn't the same, we can't use this request. + if (request->GetCORSMode() != corsmode) { + return false; + } else if (request->GetCORSMode() != imgIRequest::CORS_NONE || + forcePrincipalCheck) { + nsCOMPtr<nsIPrincipal> otherprincipal = request->GetLoadingPrincipal(); + + // If we previously had a principal, but we don't now, we can't use this + // request. + if (otherprincipal && !loadingPrincipal) { + return false; + } + + if (otherprincipal && loadingPrincipal) { + bool equals = false; + otherprincipal->Equals(loadingPrincipal, &equals); + if (!equals) { + return false; + } + } + } + + // Content Policy Check on Cached Images + return ShouldLoadCachedImage(request, aCX, loadingPrincipal, aPolicyType); +} + +static nsresult +NewImageChannel(nsIChannel** aResult, + // If aForcePrincipalCheckForCacheEntry is true, then we will + // force a principal check even when not using CORS before + // assuming we have a cache hit on a cache entry that we + // create for this channel. This is an out param that should + // be set to true if this channel ends up depending on + // aLoadingPrincipal and false otherwise. + bool* aForcePrincipalCheckForCacheEntry, + nsIURI* aURI, + nsIURI* aInitialDocumentURI, + int32_t aCORSMode, + nsIURI* aReferringURI, + ReferrerPolicy aReferrerPolicy, + nsILoadGroup* aLoadGroup, + const nsCString& aAcceptHeader, + nsLoadFlags aLoadFlags, + nsContentPolicyType aPolicyType, + nsIPrincipal* aLoadingPrincipal, + nsISupports* aRequestingContext, + bool aRespectPrivacy) +{ + MOZ_ASSERT(aResult); + + nsresult rv; + nsCOMPtr<nsIHttpChannel> newHttpChannel; + + nsCOMPtr<nsIInterfaceRequestor> callbacks; + + if (aLoadGroup) { + // Get the notification callbacks from the load group for the new channel. + // + // XXX: This is not exactly correct, because the network request could be + // referenced by multiple windows... However, the new channel needs + // something. So, using the 'first' notification callbacks is better + // than nothing... + // + aLoadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks)); + } + + // Pass in a nullptr loadgroup because this is the underlying network + // request. This request may be referenced by several proxy image requests + // (possibly in different documents). + // If all of the proxy requests are canceled then this request should be + // canceled too. + // + aLoadFlags |= nsIChannel::LOAD_CLASSIFY_URI; + + nsCOMPtr<nsINode> requestingNode = do_QueryInterface(aRequestingContext); + + nsSecurityFlags securityFlags = + aCORSMode == imgIRequest::CORS_NONE + ? nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS + : nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS; + if (aCORSMode == imgIRequest::CORS_ANONYMOUS) { + securityFlags |= nsILoadInfo::SEC_COOKIES_SAME_ORIGIN; + } else if (aCORSMode == imgIRequest::CORS_USE_CREDENTIALS) { + securityFlags |= nsILoadInfo::SEC_COOKIES_INCLUDE; + } + securityFlags |= nsILoadInfo::SEC_ALLOW_CHROME; + + // Note we are calling NS_NewChannelWithTriggeringPrincipal() here with a + // node and a principal. This is for things like background images that are + // specified by user stylesheets, where the document is being styled, but + // the principal is that of the user stylesheet. + if (requestingNode && aLoadingPrincipal) { + rv = NS_NewChannelWithTriggeringPrincipal(aResult, + aURI, + requestingNode, + aLoadingPrincipal, + securityFlags, + aPolicyType, + nullptr, // loadGroup + callbacks, + aLoadFlags); + + if (NS_FAILED(rv)) { + return rv; + } + + if (aPolicyType == nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON) { + // If this is a favicon loading, we will use the originAttributes from the + // loadingPrincipal as the channel's originAttributes. This allows the favicon + // loading from XUL will use the correct originAttributes. + NeckoOriginAttributes neckoAttrs; + neckoAttrs.InheritFromDocToNecko(BasePrincipal::Cast(aLoadingPrincipal)->OriginAttributesRef()); + + nsCOMPtr<nsILoadInfo> loadInfo = (*aResult)->GetLoadInfo(); + rv = loadInfo->SetOriginAttributes(neckoAttrs); + } + } else { + // either we are loading something inside a document, in which case + // we should always have a requestingNode, or we are loading something + // outside a document, in which case the loadingPrincipal and + // triggeringPrincipal should always be the systemPrincipal. + // However, there are exceptions: one is Notifications which create a + // channel in the parent prcoess in which case we can't get a requestingNode. + rv = NS_NewChannel(aResult, + aURI, + nsContentUtils::GetSystemPrincipal(), + securityFlags, + aPolicyType, + nullptr, // loadGroup + callbacks, + aLoadFlags); + + if (NS_FAILED(rv)) { + return rv; + } + + // Use the OriginAttributes from the loading principal, if one is available, + // and adjust the private browsing ID based on what kind of load the caller + // has asked us to perform. + NeckoOriginAttributes neckoAttrs; + if (aLoadingPrincipal) { + neckoAttrs.InheritFromDocToNecko(BasePrincipal::Cast(aLoadingPrincipal)->OriginAttributesRef()); + } + neckoAttrs.mPrivateBrowsingId = aRespectPrivacy ? 1 : 0; + + nsCOMPtr<nsILoadInfo> loadInfo = (*aResult)->GetLoadInfo(); + rv = loadInfo->SetOriginAttributes(neckoAttrs); + } + + if (NS_FAILED(rv)) { + return rv; + } + + // only inherit if we have a principal + *aForcePrincipalCheckForCacheEntry = + aLoadingPrincipal && + nsContentUtils::ChannelShouldInheritPrincipal( + aLoadingPrincipal, + aURI, + /* aInheritForAboutBlank */ false, + /* aForceInherit */ false); + + // Initialize HTTP-specific attributes + newHttpChannel = do_QueryInterface(*aResult); + if (newHttpChannel) { + newHttpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Accept"), + aAcceptHeader, + false); + + nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal = + do_QueryInterface(newHttpChannel); + NS_ENSURE_TRUE(httpChannelInternal, NS_ERROR_UNEXPECTED); + httpChannelInternal->SetDocumentURI(aInitialDocumentURI); + newHttpChannel->SetReferrerWithPolicy(aReferringURI, aReferrerPolicy); + } + + // Image channels are loaded by default with reduced priority. + nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(*aResult); + if (p) { + uint32_t priority = nsISupportsPriority::PRIORITY_LOW; + + if (aLoadFlags & nsIRequest::LOAD_BACKGROUND) { + ++priority; // further reduce priority for background loads + } + + p->AdjustPriority(priority); + } + + // Create a new loadgroup for this new channel, using the old group as + // the parent. The indirection keeps the channel insulated from cancels, + // but does allow a way for this revalidation to be associated with at + // least one base load group for scheduling/caching purposes. + + nsCOMPtr<nsILoadGroup> loadGroup = do_CreateInstance(NS_LOADGROUP_CONTRACTID); + nsCOMPtr<nsILoadGroupChild> childLoadGroup = do_QueryInterface(loadGroup); + if (childLoadGroup) { + childLoadGroup->SetParentLoadGroup(aLoadGroup); + } + (*aResult)->SetLoadGroup(loadGroup); + + return NS_OK; +} + +static uint32_t +SecondsFromPRTime(PRTime prTime) +{ + return uint32_t(int64_t(prTime) / int64_t(PR_USEC_PER_SEC)); +} + +imgCacheEntry::imgCacheEntry(imgLoader* loader, imgRequest* request, + bool forcePrincipalCheck) + : mLoader(loader), + mRequest(request), + mDataSize(0), + mTouchedTime(SecondsFromPRTime(PR_Now())), + mLoadTime(SecondsFromPRTime(PR_Now())), + mExpiryTime(0), + mMustValidate(false), + // We start off as evicted so we don't try to update the cache. PutIntoCache + // will set this to false. + mEvicted(true), + mHasNoProxies(true), + mForcePrincipalCheck(forcePrincipalCheck) +{ } + +imgCacheEntry::~imgCacheEntry() +{ + LOG_FUNC(gImgLog, "imgCacheEntry::~imgCacheEntry()"); +} + +void +imgCacheEntry::Touch(bool updateTime /* = true */) +{ + LOG_SCOPE(gImgLog, "imgCacheEntry::Touch"); + + if (updateTime) { + mTouchedTime = SecondsFromPRTime(PR_Now()); + } + + UpdateCache(); +} + +void +imgCacheEntry::UpdateCache(int32_t diff /* = 0 */) +{ + // Don't update the cache if we've been removed from it or it doesn't care + // about our size or usage. + if (!Evicted() && HasNoProxies()) { + mLoader->CacheEntriesChanged(mRequest->IsChrome(), diff); + } +} + +void imgCacheEntry::UpdateLoadTime() +{ + mLoadTime = SecondsFromPRTime(PR_Now()); +} + +void +imgCacheEntry::SetHasNoProxies(bool hasNoProxies) +{ + if (MOZ_LOG_TEST(gImgLog, LogLevel::Debug)) { + if (hasNoProxies) { + LOG_FUNC_WITH_PARAM(gImgLog, "imgCacheEntry::SetHasNoProxies true", + "uri", mRequest->CacheKey().Spec()); + } else { + LOG_FUNC_WITH_PARAM(gImgLog, "imgCacheEntry::SetHasNoProxies false", + "uri", mRequest->CacheKey().Spec()); + } + } + + mHasNoProxies = hasNoProxies; +} + +imgCacheQueue::imgCacheQueue() + : mDirty(false), + mSize(0) +{ } + +void +imgCacheQueue::UpdateSize(int32_t diff) +{ + mSize += diff; +} + +uint32_t +imgCacheQueue::GetSize() const +{ + return mSize; +} + +#include <algorithm> +using namespace std; + +void +imgCacheQueue::Remove(imgCacheEntry* entry) +{ + queueContainer::iterator it = find(mQueue.begin(), mQueue.end(), entry); + if (it != mQueue.end()) { + mSize -= (*it)->GetDataSize(); + mQueue.erase(it); + MarkDirty(); + } +} + +void +imgCacheQueue::Push(imgCacheEntry* entry) +{ + mSize += entry->GetDataSize(); + + RefPtr<imgCacheEntry> refptr(entry); + mQueue.push_back(refptr); + MarkDirty(); +} + +already_AddRefed<imgCacheEntry> +imgCacheQueue::Pop() +{ + if (mQueue.empty()) { + return nullptr; + } + if (IsDirty()) { + Refresh(); + } + + RefPtr<imgCacheEntry> entry = mQueue[0]; + std::pop_heap(mQueue.begin(), mQueue.end(), imgLoader::CompareCacheEntries); + mQueue.pop_back(); + + mSize -= entry->GetDataSize(); + return entry.forget(); +} + +void +imgCacheQueue::Refresh() +{ + std::make_heap(mQueue.begin(), mQueue.end(), imgLoader::CompareCacheEntries); + mDirty = false; +} + +void +imgCacheQueue::MarkDirty() +{ + mDirty = true; +} + +bool +imgCacheQueue::IsDirty() +{ + return mDirty; +} + +uint32_t +imgCacheQueue::GetNumElements() const +{ + return mQueue.size(); +} + +imgCacheQueue::iterator +imgCacheQueue::begin() +{ + return mQueue.begin(); +} + +imgCacheQueue::const_iterator +imgCacheQueue::begin() const +{ + return mQueue.begin(); +} + +imgCacheQueue::iterator +imgCacheQueue::end() +{ + return mQueue.end(); +} + +imgCacheQueue::const_iterator +imgCacheQueue::end() const +{ + return mQueue.end(); +} + +nsresult +imgLoader::CreateNewProxyForRequest(imgRequest* aRequest, + nsILoadGroup* aLoadGroup, + imgINotificationObserver* aObserver, + nsLoadFlags aLoadFlags, + imgRequestProxy** _retval) +{ + LOG_SCOPE_WITH_PARAM(gImgLog, "imgLoader::CreateNewProxyForRequest", + "imgRequest", aRequest); + + /* XXX If we move decoding onto separate threads, we should save off the + calling thread here and pass it off to |proxyRequest| so that it call + proxy calls to |aObserver|. + */ + + RefPtr<imgRequestProxy> proxyRequest = new imgRequestProxy(); + + /* It is important to call |SetLoadFlags()| before calling |Init()| because + |Init()| adds the request to the loadgroup. + */ + proxyRequest->SetLoadFlags(aLoadFlags); + + RefPtr<ImageURL> uri; + aRequest->GetURI(getter_AddRefs(uri)); + + // init adds itself to imgRequest's list of observers + nsresult rv = proxyRequest->Init(aRequest, aLoadGroup, uri, aObserver); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + proxyRequest.forget(_retval); + return NS_OK; +} + +class imgCacheExpirationTracker final + : public nsExpirationTracker<imgCacheEntry, 3> +{ + enum { TIMEOUT_SECONDS = 10 }; +public: + imgCacheExpirationTracker(); + +protected: + void NotifyExpired(imgCacheEntry* entry); +}; + +imgCacheExpirationTracker::imgCacheExpirationTracker() + : nsExpirationTracker<imgCacheEntry, 3>(TIMEOUT_SECONDS * 1000, + "imgCacheExpirationTracker") +{ } + +void +imgCacheExpirationTracker::NotifyExpired(imgCacheEntry* entry) +{ + // Hold on to a reference to this entry, because the expiration tracker + // mechanism doesn't. + RefPtr<imgCacheEntry> kungFuDeathGrip(entry); + + if (MOZ_LOG_TEST(gImgLog, LogLevel::Debug)) { + RefPtr<imgRequest> req = entry->GetRequest(); + if (req) { + LOG_FUNC_WITH_PARAM(gImgLog, + "imgCacheExpirationTracker::NotifyExpired", + "entry", req->CacheKey().Spec()); + } + } + + // We can be called multiple times on the same entry. Don't do work multiple + // times. + if (!entry->Evicted()) { + entry->Loader()->RemoveFromCache(entry); + } + + entry->Loader()->VerifyCacheSizes(); +} + + +/////////////////////////////////////////////////////////////////////////////// +// imgLoader +/////////////////////////////////////////////////////////////////////////////// + +double imgLoader::sCacheTimeWeight; +uint32_t imgLoader::sCacheMaxSize; +imgMemoryReporter* imgLoader::sMemReporter; + +NS_IMPL_ISUPPORTS(imgLoader, imgILoader, nsIContentSniffer, imgICache, + nsISupportsWeakReference, nsIObserver) + +static imgLoader* gNormalLoader = nullptr; +static imgLoader* gPrivateBrowsingLoader = nullptr; + +/* static */ already_AddRefed<imgLoader> +imgLoader::CreateImageLoader() +{ + // In some cases, such as xpctests, XPCOM modules are not automatically + // initialized. We need to make sure that our module is initialized before + // we hand out imgLoader instances and code starts using them. + mozilla::image::EnsureModuleInitialized(); + + RefPtr<imgLoader> loader = new imgLoader(); + loader->Init(); + + return loader.forget(); +} + +imgLoader* +imgLoader::NormalLoader() +{ + if (!gNormalLoader) { + gNormalLoader = CreateImageLoader().take(); + } + return gNormalLoader; +} + +imgLoader* +imgLoader::PrivateBrowsingLoader() +{ + if (!gPrivateBrowsingLoader) { + gPrivateBrowsingLoader = CreateImageLoader().take(); + gPrivateBrowsingLoader->RespectPrivacyNotifications(); + } + return gPrivateBrowsingLoader; +} + +imgLoader::imgLoader() +: mUncachedImagesMutex("imgLoader::UncachedImages"), mRespectPrivacy(false) +{ + sMemReporter->AddRef(); + sMemReporter->RegisterLoader(this); +} + +imgLoader::~imgLoader() +{ + ClearChromeImageCache(); + ClearImageCache(); + { + // If there are any of our imgRequest's left they are in the uncached + // images set, so clear their pointer to us. + MutexAutoLock lock(mUncachedImagesMutex); + for (auto iter = mUncachedImages.Iter(); !iter.Done(); iter.Next()) { + nsPtrHashKey<imgRequest>* entry = iter.Get(); + RefPtr<imgRequest> req = entry->GetKey(); + req->ClearLoader(); + } + } + sMemReporter->UnregisterLoader(this); + sMemReporter->Release(); +} + +void +imgLoader::VerifyCacheSizes() +{ +#ifdef DEBUG + if (!mCacheTracker) { + return; + } + + uint32_t cachesize = mCache.Count() + mChromeCache.Count(); + uint32_t queuesize = + mCacheQueue.GetNumElements() + mChromeCacheQueue.GetNumElements(); + uint32_t trackersize = 0; + for (nsExpirationTracker<imgCacheEntry, 3>::Iterator it(mCacheTracker.get()); + it.Next(); ){ + trackersize++; + } + MOZ_ASSERT(queuesize == trackersize, "Queue and tracker sizes out of sync!"); + MOZ_ASSERT(queuesize <= cachesize, "Queue has more elements than cache!"); +#endif +} + +imgLoader::imgCacheTable& +imgLoader::GetCache(bool aForChrome) +{ + return aForChrome ? mChromeCache : mCache; +} + +imgLoader::imgCacheTable& +imgLoader::GetCache(const ImageCacheKey& aKey) +{ + return GetCache(aKey.IsChrome()); +} + +imgCacheQueue& +imgLoader::GetCacheQueue(bool aForChrome) +{ + return aForChrome ? mChromeCacheQueue : mCacheQueue; + +} + +imgCacheQueue& +imgLoader::GetCacheQueue(const ImageCacheKey& aKey) +{ + return GetCacheQueue(aKey.IsChrome()); + +} + +void imgLoader::GlobalInit() +{ + sCacheTimeWeight = gfxPrefs::ImageCacheTimeWeight() / 1000.0; + int32_t cachesize = gfxPrefs::ImageCacheSize(); + sCacheMaxSize = cachesize > 0 ? cachesize : 0; + + sMemReporter = new imgMemoryReporter(); + RegisterStrongMemoryReporter(sMemReporter); + RegisterImagesContentUsedUncompressedDistinguishedAmount( + imgMemoryReporter::ImagesContentUsedUncompressedDistinguishedAmount); +} + +void imgLoader::ShutdownMemoryReporter() +{ + UnregisterImagesContentUsedUncompressedDistinguishedAmount(); + UnregisterStrongMemoryReporter(sMemReporter); +} + +nsresult +imgLoader::InitCache() +{ + nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService(); + if (!os) { + return NS_ERROR_FAILURE; + } + + os->AddObserver(this, "memory-pressure", false); + os->AddObserver(this, "chrome-flush-skin-caches", false); + os->AddObserver(this, "chrome-flush-caches", false); + os->AddObserver(this, "last-pb-context-exited", false); + os->AddObserver(this, "profile-before-change", false); + os->AddObserver(this, "xpcom-shutdown", false); + + mCacheTracker = MakeUnique<imgCacheExpirationTracker>(); + + return NS_OK; +} + +nsresult +imgLoader::Init() +{ + InitCache(); + + ReadAcceptHeaderPref(); + + Preferences::AddWeakObserver(this, "image.http.accept"); + + return NS_OK; +} + +NS_IMETHODIMP +imgLoader::RespectPrivacyNotifications() +{ + mRespectPrivacy = true; + return NS_OK; +} + +NS_IMETHODIMP +imgLoader::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) +{ + // We listen for pref change notifications... + if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) { + if (!NS_strcmp(aData, u"image.http.accept")) { + ReadAcceptHeaderPref(); + } + + } else if (strcmp(aTopic, "memory-pressure") == 0) { + MinimizeCaches(); + } else if (strcmp(aTopic, "chrome-flush-skin-caches") == 0 || + strcmp(aTopic, "chrome-flush-caches") == 0) { + MinimizeCaches(); + ClearChromeImageCache(); + } else if (strcmp(aTopic, "last-pb-context-exited") == 0) { + if (mRespectPrivacy) { + ClearImageCache(); + ClearChromeImageCache(); + } + } else if (strcmp(aTopic, "profile-before-change") == 0) { + mCacheTracker = nullptr; + } else if (strcmp(aTopic, "xpcom-shutdown") == 0) { + mCacheTracker = nullptr; + ShutdownMemoryReporter(); + + } else { + // (Nothing else should bring us here) + MOZ_ASSERT(0, "Invalid topic received"); + } + + return NS_OK; +} + +void imgLoader::ReadAcceptHeaderPref() +{ + nsAdoptingCString accept = Preferences::GetCString("image.http.accept"); + if (accept) { + mAcceptHeader = accept; + } else { + mAcceptHeader = + IMAGE_PNG "," IMAGE_WILDCARD ";q=0.8," ANY_WILDCARD ";q=0.5"; + } +} + +NS_IMETHODIMP +imgLoader::ClearCache(bool chrome) +{ + if (XRE_IsParentProcess()) { + bool privateLoader = this == gPrivateBrowsingLoader; + for (auto* cp : ContentParent::AllProcesses(ContentParent::eLive)) { + Unused << cp->SendClearImageCache(privateLoader, chrome); + } + } + + if (chrome) { + return ClearChromeImageCache(); + } else { + return ClearImageCache(); + } +} + +NS_IMETHODIMP +imgLoader::FindEntryProperties(nsIURI* uri, + nsIDOMDocument* aDOMDoc, + nsIProperties** _retval) +{ + *_retval = nullptr; + + nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDOMDoc); + + PrincipalOriginAttributes attrs; + if (doc) { + nsCOMPtr<nsIPrincipal> principal = doc->NodePrincipal(); + if (principal) { + attrs = BasePrincipal::Cast(principal)->OriginAttributesRef(); + } + } + + nsresult rv; + ImageCacheKey key(uri, attrs, doc, rv); + NS_ENSURE_SUCCESS(rv, rv); + imgCacheTable& cache = GetCache(key); + + RefPtr<imgCacheEntry> entry; + if (cache.Get(key, getter_AddRefs(entry)) && entry) { + if (mCacheTracker && entry->HasNoProxies()) { + mCacheTracker->MarkUsed(entry); + } + + RefPtr<imgRequest> request = entry->GetRequest(); + if (request) { + nsCOMPtr<nsIProperties> properties = request->Properties(); + properties.forget(_retval); + } + } + + return NS_OK; +} + +NS_IMETHODIMP_(void) +imgLoader::ClearCacheForControlledDocument(nsIDocument* aDoc) +{ + MOZ_ASSERT(aDoc); + AutoTArray<RefPtr<imgCacheEntry>, 128> entriesToBeRemoved; + imgCacheTable& cache = GetCache(false); + for (auto iter = cache.Iter(); !iter.Done(); iter.Next()) { + auto& key = iter.Key(); + if (key.ControlledDocument() == aDoc) { + entriesToBeRemoved.AppendElement(iter.Data()); + } + } + for (auto& entry : entriesToBeRemoved) { + if (!RemoveFromCache(entry)) { + NS_WARNING("Couldn't remove an entry from the cache in ClearCacheForControlledDocument()\n"); + } + } +} + +void +imgLoader::Shutdown() +{ + NS_IF_RELEASE(gNormalLoader); + gNormalLoader = nullptr; + NS_IF_RELEASE(gPrivateBrowsingLoader); + gPrivateBrowsingLoader = nullptr; +} + +nsresult +imgLoader::ClearChromeImageCache() +{ + return EvictEntries(mChromeCache); +} + +nsresult +imgLoader::ClearImageCache() +{ + return EvictEntries(mCache); +} + +void +imgLoader::MinimizeCaches() +{ + EvictEntries(mCacheQueue); + EvictEntries(mChromeCacheQueue); +} + +bool +imgLoader::PutIntoCache(const ImageCacheKey& aKey, imgCacheEntry* entry) +{ + imgCacheTable& cache = GetCache(aKey); + + LOG_STATIC_FUNC_WITH_PARAM(gImgLog, + "imgLoader::PutIntoCache", "uri", aKey.Spec()); + + // Check to see if this request already exists in the cache. If so, we'll + // replace the old version. + RefPtr<imgCacheEntry> tmpCacheEntry; + if (cache.Get(aKey, getter_AddRefs(tmpCacheEntry)) && tmpCacheEntry) { + MOZ_LOG(gImgLog, LogLevel::Debug, + ("[this=%p] imgLoader::PutIntoCache -- Element already in the cache", + nullptr)); + RefPtr<imgRequest> tmpRequest = tmpCacheEntry->GetRequest(); + + // If it already exists, and we're putting the same key into the cache, we + // should remove the old version. + MOZ_LOG(gImgLog, LogLevel::Debug, + ("[this=%p] imgLoader::PutIntoCache -- Replacing cached element", + nullptr)); + + RemoveFromCache(aKey); + } else { + MOZ_LOG(gImgLog, LogLevel::Debug, + ("[this=%p] imgLoader::PutIntoCache --" + " Element NOT already in the cache", nullptr)); + } + + cache.Put(aKey, entry); + + // We can be called to resurrect an evicted entry. + if (entry->Evicted()) { + entry->SetEvicted(false); + } + + // If we're resurrecting an entry with no proxies, put it back in the + // tracker and queue. + if (entry->HasNoProxies()) { + nsresult addrv = NS_OK; + + if (mCacheTracker) { + addrv = mCacheTracker->AddObject(entry); + } + + if (NS_SUCCEEDED(addrv)) { + imgCacheQueue& queue = GetCacheQueue(aKey); + queue.Push(entry); + } + } + + RefPtr<imgRequest> request = entry->GetRequest(); + request->SetIsInCache(true); + RemoveFromUncachedImages(request); + + return true; +} + +bool +imgLoader::SetHasNoProxies(imgRequest* aRequest, imgCacheEntry* aEntry) +{ + LOG_STATIC_FUNC_WITH_PARAM(gImgLog, + "imgLoader::SetHasNoProxies", "uri", + aRequest->CacheKey().Spec()); + + aEntry->SetHasNoProxies(true); + + if (aEntry->Evicted()) { + return false; + } + + imgCacheQueue& queue = GetCacheQueue(aRequest->IsChrome()); + + nsresult addrv = NS_OK; + + if (mCacheTracker) { + addrv = mCacheTracker->AddObject(aEntry); + } + + if (NS_SUCCEEDED(addrv)) { + queue.Push(aEntry); + } + + imgCacheTable& cache = GetCache(aRequest->IsChrome()); + CheckCacheLimits(cache, queue); + + return true; +} + +bool +imgLoader::SetHasProxies(imgRequest* aRequest) +{ + VerifyCacheSizes(); + + const ImageCacheKey& key = aRequest->CacheKey(); + imgCacheTable& cache = GetCache(key); + + LOG_STATIC_FUNC_WITH_PARAM(gImgLog, + "imgLoader::SetHasProxies", "uri", key.Spec()); + + RefPtr<imgCacheEntry> entry; + if (cache.Get(key, getter_AddRefs(entry)) && entry) { + // Make sure the cache entry is for the right request + RefPtr<imgRequest> entryRequest = entry->GetRequest(); + if (entryRequest == aRequest && entry->HasNoProxies()) { + imgCacheQueue& queue = GetCacheQueue(key); + queue.Remove(entry); + + if (mCacheTracker) { + mCacheTracker->RemoveObject(entry); + } + + entry->SetHasNoProxies(false); + + return true; + } + } + + return false; +} + +void +imgLoader::CacheEntriesChanged(bool aForChrome, int32_t aSizeDiff /* = 0 */) +{ + imgCacheQueue& queue = GetCacheQueue(aForChrome); + queue.MarkDirty(); + queue.UpdateSize(aSizeDiff); +} + +void +imgLoader::CheckCacheLimits(imgCacheTable& cache, imgCacheQueue& queue) +{ + if (queue.GetNumElements() == 0) { + NS_ASSERTION(queue.GetSize() == 0, + "imgLoader::CheckCacheLimits -- incorrect cache size"); + } + + // Remove entries from the cache until we're back at our desired max size. + while (queue.GetSize() > sCacheMaxSize) { + // Remove the first entry in the queue. + RefPtr<imgCacheEntry> entry(queue.Pop()); + + NS_ASSERTION(entry, "imgLoader::CheckCacheLimits -- NULL entry pointer"); + + if (MOZ_LOG_TEST(gImgLog, LogLevel::Debug)) { + RefPtr<imgRequest> req = entry->GetRequest(); + if (req) { + LOG_STATIC_FUNC_WITH_PARAM(gImgLog, + "imgLoader::CheckCacheLimits", + "entry", req->CacheKey().Spec()); + } + } + + if (entry) { + RemoveFromCache(entry); + } + } +} + +bool +imgLoader::ValidateRequestWithNewChannel(imgRequest* request, + nsIURI* aURI, + nsIURI* aInitialDocumentURI, + nsIURI* aReferrerURI, + ReferrerPolicy aReferrerPolicy, + nsILoadGroup* aLoadGroup, + imgINotificationObserver* aObserver, + nsISupports* aCX, + nsLoadFlags aLoadFlags, + nsContentPolicyType aLoadPolicyType, + imgRequestProxy** aProxyRequest, + nsIPrincipal* aLoadingPrincipal, + int32_t aCORSMode) +{ + // now we need to insert a new channel request object inbetween the real + // request and the proxy that basically delays loading the image until it + // gets a 304 or figures out that this needs to be a new request + + nsresult rv; + + // If we're currently in the middle of validating this request, just hand + // back a proxy to it; the required work will be done for us. + if (request->GetValidator()) { + rv = CreateNewProxyForRequest(request, aLoadGroup, aObserver, + aLoadFlags, aProxyRequest); + if (NS_FAILED(rv)) { + return false; + } + + if (*aProxyRequest) { + imgRequestProxy* proxy = static_cast<imgRequestProxy*>(*aProxyRequest); + + // We will send notifications from imgCacheValidator::OnStartRequest(). + // In the mean time, we must defer notifications because we are added to + // the imgRequest's proxy list, and we can get extra notifications + // resulting from methods such as StartDecoding(). See bug 579122. + proxy->SetNotificationsDeferred(true); + + // Attach the proxy without notifying + request->GetValidator()->AddProxy(proxy); + } + + return NS_SUCCEEDED(rv); + + } else { + // We will rely on Necko to cache this request when it's possible, and to + // tell imgCacheValidator::OnStartRequest whether the request came from its + // cache. + nsCOMPtr<nsIChannel> newChannel; + bool forcePrincipalCheck; + rv = NewImageChannel(getter_AddRefs(newChannel), + &forcePrincipalCheck, + aURI, + aInitialDocumentURI, + aCORSMode, + aReferrerURI, + aReferrerPolicy, + aLoadGroup, + mAcceptHeader, + aLoadFlags, + aLoadPolicyType, + aLoadingPrincipal, + aCX, + mRespectPrivacy); + if (NS_FAILED(rv)) { + return false; + } + + RefPtr<imgRequestProxy> req; + rv = CreateNewProxyForRequest(request, aLoadGroup, aObserver, + aLoadFlags, getter_AddRefs(req)); + if (NS_FAILED(rv)) { + return false; + } + + // Make sure that OnStatus/OnProgress calls have the right request set... + RefPtr<nsProgressNotificationProxy> progressproxy = + new nsProgressNotificationProxy(newChannel, req); + if (!progressproxy) { + return false; + } + + RefPtr<imgCacheValidator> hvc = + new imgCacheValidator(progressproxy, this, request, aCX, + forcePrincipalCheck); + + // Casting needed here to get past multiple inheritance. + nsCOMPtr<nsIStreamListener> listener = + do_QueryInterface(static_cast<nsIThreadRetargetableStreamListener*>(hvc)); + NS_ENSURE_TRUE(listener, false); + + // We must set the notification callbacks before setting up the + // CORS listener, because that's also interested inthe + // notification callbacks. + newChannel->SetNotificationCallbacks(hvc); + + request->SetValidator(hvc); + + // We will send notifications from imgCacheValidator::OnStartRequest(). + // In the mean time, we must defer notifications because we are added to + // the imgRequest's proxy list, and we can get extra notifications + // resulting from methods such as StartDecoding(). See bug 579122. + req->SetNotificationsDeferred(true); + + // Add the proxy without notifying + hvc->AddProxy(req); + + mozilla::net::PredictorLearn(aURI, aInitialDocumentURI, + nsINetworkPredictor::LEARN_LOAD_SUBRESOURCE, aLoadGroup); + + rv = newChannel->AsyncOpen2(listener); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + + req.forget(aProxyRequest); + return true; + } +} + +bool +imgLoader::ValidateEntry(imgCacheEntry* aEntry, + nsIURI* aURI, + nsIURI* aInitialDocumentURI, + nsIURI* aReferrerURI, + ReferrerPolicy aReferrerPolicy, + nsILoadGroup* aLoadGroup, + imgINotificationObserver* aObserver, + nsISupports* aCX, + nsLoadFlags aLoadFlags, + nsContentPolicyType aLoadPolicyType, + bool aCanMakeNewChannel, + imgRequestProxy** aProxyRequest, + nsIPrincipal* aLoadingPrincipal, + int32_t aCORSMode) +{ + LOG_SCOPE(gImgLog, "imgLoader::ValidateEntry"); + + bool hasExpired; + uint32_t expirationTime = aEntry->GetExpiryTime(); + if (expirationTime <= SecondsFromPRTime(PR_Now())) { + hasExpired = true; + } else { + hasExpired = false; + } + + nsresult rv; + + // Special treatment for file URLs - aEntry has expired if file has changed + nsCOMPtr<nsIFileURL> fileUrl(do_QueryInterface(aURI)); + if (fileUrl) { + uint32_t lastModTime = aEntry->GetLoadTime(); + + nsCOMPtr<nsIFile> theFile; + rv = fileUrl->GetFile(getter_AddRefs(theFile)); + if (NS_SUCCEEDED(rv)) { + PRTime fileLastMod; + rv = theFile->GetLastModifiedTime(&fileLastMod); + if (NS_SUCCEEDED(rv)) { + // nsIFile uses millisec, NSPR usec + fileLastMod *= 1000; + hasExpired = SecondsFromPRTime((PRTime)fileLastMod) > lastModTime; + } + } + } + + RefPtr<imgRequest> request(aEntry->GetRequest()); + + if (!request) { + return false; + } + + if (!ValidateSecurityInfo(request, aEntry->ForcePrincipalCheck(), + aCORSMode, aLoadingPrincipal, + aCX, aLoadPolicyType, aReferrerPolicy)) + return false; + + // data URIs are immutable and by their nature can't leak data, so we can + // just return true in that case. Doing so would mean that shift-reload + // doesn't reload data URI documents/images though (which is handy for + // debugging during gecko development) so we make an exception in that case. + nsAutoCString scheme; + aURI->GetScheme(scheme); + if (scheme.EqualsLiteral("data") && + !(aLoadFlags & nsIRequest::LOAD_BYPASS_CACHE)) { + return true; + } + + bool validateRequest = false; + + // If the request's loadId is the same as the aCX, then it is ok to use + // this one because it has already been validated for this context. + // + // XXX: nullptr seems to be a 'special' key value that indicates that NO + // validation is required. + // + void *key = (void*) aCX; + if (request->LoadId() != key) { + // If we would need to revalidate this entry, but we're being told to + // bypass the cache, we don't allow this entry to be used. + if (aLoadFlags & nsIRequest::LOAD_BYPASS_CACHE) { + return false; + } + + if (MOZ_UNLIKELY(ChaosMode::isActive(ChaosFeature::ImageCache))) { + if (ChaosMode::randomUint32LessThan(4) < 1) { + return false; + } + } + + // Determine whether the cache aEntry must be revalidated... + validateRequest = ShouldRevalidateEntry(aEntry, aLoadFlags, hasExpired); + + MOZ_LOG(gImgLog, LogLevel::Debug, + ("imgLoader::ValidateEntry validating cache entry. " + "validateRequest = %d", validateRequest)); + } else if (!key && MOZ_LOG_TEST(gImgLog, LogLevel::Debug)) { + MOZ_LOG(gImgLog, LogLevel::Debug, + ("imgLoader::ValidateEntry BYPASSING cache validation for %s " + "because of NULL LoadID", aURI->GetSpecOrDefault().get())); + } + + // We can't use a cached request if it comes from a different + // application cache than this load is expecting. + nsCOMPtr<nsIApplicationCacheContainer> appCacheContainer; + nsCOMPtr<nsIApplicationCache> requestAppCache; + nsCOMPtr<nsIApplicationCache> groupAppCache; + if ((appCacheContainer = do_GetInterface(request->GetRequest()))) { + appCacheContainer->GetApplicationCache(getter_AddRefs(requestAppCache)); + } + if ((appCacheContainer = do_QueryInterface(aLoadGroup))) { + appCacheContainer->GetApplicationCache(getter_AddRefs(groupAppCache)); + } + + if (requestAppCache != groupAppCache) { + MOZ_LOG(gImgLog, LogLevel::Debug, + ("imgLoader::ValidateEntry - Unable to use cached imgRequest " + "[request=%p] because of mismatched application caches\n", + address_of(request))); + return false; + } + + if (validateRequest && aCanMakeNewChannel) { + LOG_SCOPE(gImgLog, + "imgLoader::ValidateRequest |cache hit| must validate"); + + return ValidateRequestWithNewChannel(request, aURI, aInitialDocumentURI, + aReferrerURI, aReferrerPolicy, + aLoadGroup, aObserver, + aCX, aLoadFlags, aLoadPolicyType, + aProxyRequest, aLoadingPrincipal, + aCORSMode); + } + + return !validateRequest; +} + +bool +imgLoader::RemoveFromCache(const ImageCacheKey& aKey) +{ + LOG_STATIC_FUNC_WITH_PARAM(gImgLog, + "imgLoader::RemoveFromCache", "uri", aKey.Spec()); + + imgCacheTable& cache = GetCache(aKey); + imgCacheQueue& queue = GetCacheQueue(aKey); + + RefPtr<imgCacheEntry> entry; + if (cache.Get(aKey, getter_AddRefs(entry)) && entry) { + cache.Remove(aKey); + + MOZ_ASSERT(!entry->Evicted(), "Evicting an already-evicted cache entry!"); + + // Entries with no proxies are in the tracker. + if (entry->HasNoProxies()) { + if (mCacheTracker) { + mCacheTracker->RemoveObject(entry); + } + queue.Remove(entry); + } + + entry->SetEvicted(true); + + RefPtr<imgRequest> request = entry->GetRequest(); + request->SetIsInCache(false); + AddToUncachedImages(request); + + return true; + + } else { + return false; + } +} + +bool +imgLoader::RemoveFromCache(imgCacheEntry* entry) +{ + LOG_STATIC_FUNC(gImgLog, "imgLoader::RemoveFromCache entry"); + + RefPtr<imgRequest> request = entry->GetRequest(); + if (request) { + const ImageCacheKey& key = request->CacheKey(); + imgCacheTable& cache = GetCache(key); + imgCacheQueue& queue = GetCacheQueue(key); + + LOG_STATIC_FUNC_WITH_PARAM(gImgLog, + "imgLoader::RemoveFromCache", "entry's uri", + key.Spec()); + + cache.Remove(key); + + if (entry->HasNoProxies()) { + LOG_STATIC_FUNC(gImgLog, + "imgLoader::RemoveFromCache removing from tracker"); + if (mCacheTracker) { + mCacheTracker->RemoveObject(entry); + } + queue.Remove(entry); + } + + entry->SetEvicted(true); + request->SetIsInCache(false); + AddToUncachedImages(request); + + return true; + } + + return false; +} + +nsresult +imgLoader::EvictEntries(imgCacheTable& aCacheToClear) +{ + LOG_STATIC_FUNC(gImgLog, "imgLoader::EvictEntries table"); + + // We have to make a temporary, since RemoveFromCache removes the element + // from the queue, invalidating iterators. + nsTArray<RefPtr<imgCacheEntry> > entries; + for (auto iter = aCacheToClear.Iter(); !iter.Done(); iter.Next()) { + RefPtr<imgCacheEntry>& data = iter.Data(); + entries.AppendElement(data); + } + + for (uint32_t i = 0; i < entries.Length(); ++i) { + if (!RemoveFromCache(entries[i])) { + return NS_ERROR_FAILURE; + } + } + + MOZ_ASSERT(aCacheToClear.Count() == 0); + + return NS_OK; +} + +nsresult +imgLoader::EvictEntries(imgCacheQueue& aQueueToClear) +{ + LOG_STATIC_FUNC(gImgLog, "imgLoader::EvictEntries queue"); + + // We have to make a temporary, since RemoveFromCache removes the element + // from the queue, invalidating iterators. + nsTArray<RefPtr<imgCacheEntry> > entries(aQueueToClear.GetNumElements()); + for (imgCacheQueue::const_iterator i = aQueueToClear.begin(); + i != aQueueToClear.end(); ++i) { + entries.AppendElement(*i); + } + + for (uint32_t i = 0; i < entries.Length(); ++i) { + if (!RemoveFromCache(entries[i])) { + return NS_ERROR_FAILURE; + } + } + + MOZ_ASSERT(aQueueToClear.GetNumElements() == 0); + + return NS_OK; +} + +void +imgLoader::AddToUncachedImages(imgRequest* aRequest) +{ + MutexAutoLock lock(mUncachedImagesMutex); + mUncachedImages.PutEntry(aRequest); +} + +void +imgLoader::RemoveFromUncachedImages(imgRequest* aRequest) +{ + MutexAutoLock lock(mUncachedImagesMutex); + mUncachedImages.RemoveEntry(aRequest); +} + + +#define LOAD_FLAGS_CACHE_MASK (nsIRequest::LOAD_BYPASS_CACHE | \ + nsIRequest::LOAD_FROM_CACHE) + +#define LOAD_FLAGS_VALIDATE_MASK (nsIRequest::VALIDATE_ALWAYS | \ + nsIRequest::VALIDATE_NEVER | \ + nsIRequest::VALIDATE_ONCE_PER_SESSION) + +NS_IMETHODIMP +imgLoader::LoadImageXPCOM(nsIURI* aURI, + nsIURI* aInitialDocumentURI, + nsIURI* aReferrerURI, + const nsAString& aReferrerPolicy, + nsIPrincipal* aLoadingPrincipal, + nsILoadGroup* aLoadGroup, + imgINotificationObserver* aObserver, + nsISupports* aCX, + nsLoadFlags aLoadFlags, + nsISupports* aCacheKey, + nsContentPolicyType aContentPolicyType, + imgIRequest** _retval) +{ + // Optional parameter, so defaults to 0 (== TYPE_INVALID) + if (!aContentPolicyType) { + aContentPolicyType = nsIContentPolicy::TYPE_INTERNAL_IMAGE; + } + imgRequestProxy* proxy; + ReferrerPolicy refpol = ReferrerPolicyFromString(aReferrerPolicy); + nsCOMPtr<nsINode> node = do_QueryInterface(aCX); + nsCOMPtr<nsIDocument> doc = do_QueryInterface(aCX); + nsresult rv = LoadImage(aURI, + aInitialDocumentURI, + aReferrerURI, + refpol == mozilla::net::RP_Unset ? + mozilla::net::RP_Default : refpol, + aLoadingPrincipal, + aLoadGroup, + aObserver, + node, + doc, + aLoadFlags, + aCacheKey, + aContentPolicyType, + EmptyString(), + &proxy); + *_retval = proxy; + return rv; +} + +nsresult +imgLoader::LoadImage(nsIURI* aURI, + nsIURI* aInitialDocumentURI, + nsIURI* aReferrerURI, + ReferrerPolicy aReferrerPolicy, + nsIPrincipal* aLoadingPrincipal, + nsILoadGroup* aLoadGroup, + imgINotificationObserver* aObserver, + nsINode *aContext, + nsIDocument* aLoadingDocument, + nsLoadFlags aLoadFlags, + nsISupports* aCacheKey, + nsContentPolicyType aContentPolicyType, + const nsAString& initiatorType, + imgRequestProxy** _retval) +{ + VerifyCacheSizes(); + + NS_ASSERTION(aURI, "imgLoader::LoadImage -- NULL URI pointer"); + + if (!aURI) { + return NS_ERROR_NULL_POINTER; + } + + LOG_SCOPE_WITH_PARAM(gImgLog, "imgLoader::LoadImage", "aURI", + aURI->GetSpecOrDefault().get()); + + *_retval = nullptr; + + RefPtr<imgRequest> request; + + nsresult rv; + nsLoadFlags requestFlags = nsIRequest::LOAD_NORMAL; + +#ifdef DEBUG + bool isPrivate = false; + + if (aLoadGroup) { + nsCOMPtr<nsIInterfaceRequestor> callbacks; + aLoadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks)); + if (callbacks) { + nsCOMPtr<nsILoadContext> loadContext = do_GetInterface(callbacks); + isPrivate = loadContext && loadContext->UsePrivateBrowsing(); + } + } + MOZ_ASSERT(isPrivate == mRespectPrivacy); +#endif + + // Get the default load flags from the loadgroup (if possible)... + if (aLoadGroup) { + aLoadGroup->GetLoadFlags(&requestFlags); + } + // + // Merge the default load flags with those passed in via aLoadFlags. + // Currently, *only* the caching, validation and background load flags + // are merged... + // + // The flags in aLoadFlags take precedence over the default flags! + // + if (aLoadFlags & LOAD_FLAGS_CACHE_MASK) { + // Override the default caching flags... + requestFlags = (requestFlags & ~LOAD_FLAGS_CACHE_MASK) | + (aLoadFlags & LOAD_FLAGS_CACHE_MASK); + } + if (aLoadFlags & LOAD_FLAGS_VALIDATE_MASK) { + // Override the default validation flags... + requestFlags = (requestFlags & ~LOAD_FLAGS_VALIDATE_MASK) | + (aLoadFlags & LOAD_FLAGS_VALIDATE_MASK); + } + if (aLoadFlags & nsIRequest::LOAD_BACKGROUND) { + // Propagate background loading... + requestFlags |= nsIRequest::LOAD_BACKGROUND; + } + + int32_t corsmode = imgIRequest::CORS_NONE; + if (aLoadFlags & imgILoader::LOAD_CORS_ANONYMOUS) { + corsmode = imgIRequest::CORS_ANONYMOUS; + } else if (aLoadFlags & imgILoader::LOAD_CORS_USE_CREDENTIALS) { + corsmode = imgIRequest::CORS_USE_CREDENTIALS; + } + + RefPtr<imgCacheEntry> entry; + + // Look in the cache for our URI, and then validate it. + // XXX For now ignore aCacheKey. We will need it in the future + // for correctly dealing with image load requests that are a result + // of post data. + PrincipalOriginAttributes attrs; + if (aLoadingPrincipal) { + attrs = BasePrincipal::Cast(aLoadingPrincipal)->OriginAttributesRef(); + } + ImageCacheKey key(aURI, attrs, aLoadingDocument, rv); + NS_ENSURE_SUCCESS(rv, rv); + imgCacheTable& cache = GetCache(key); + + if (cache.Get(key, getter_AddRefs(entry)) && entry) { + if (ValidateEntry(entry, aURI, aInitialDocumentURI, aReferrerURI, + aReferrerPolicy, aLoadGroup, aObserver, aLoadingDocument, + requestFlags, aContentPolicyType, true, _retval, + aLoadingPrincipal, corsmode)) { + request = entry->GetRequest(); + + // If this entry has no proxies, its request has no reference to the + // entry. + if (entry->HasNoProxies()) { + LOG_FUNC_WITH_PARAM(gImgLog, + "imgLoader::LoadImage() adding proxyless entry", "uri", key.Spec()); + MOZ_ASSERT(!request->HasCacheEntry(), + "Proxyless entry's request has cache entry!"); + request->SetCacheEntry(entry); + + if (mCacheTracker && entry->GetExpirationState()->IsTracked()) { + mCacheTracker->MarkUsed(entry); + } + } + + entry->Touch(); + + } else { + // We can't use this entry. We'll try to load it off the network, and if + // successful, overwrite the old entry in the cache with a new one. + entry = nullptr; + } + } + + // Keep the channel in this scope, so we can adjust its notificationCallbacks + // later when we create the proxy. + nsCOMPtr<nsIChannel> newChannel; + // If we didn't get a cache hit, we need to load from the network. + if (!request) { + LOG_SCOPE(gImgLog, "imgLoader::LoadImage |cache miss|"); + + bool forcePrincipalCheck; + rv = NewImageChannel(getter_AddRefs(newChannel), + &forcePrincipalCheck, + aURI, + aInitialDocumentURI, + corsmode, + aReferrerURI, + aReferrerPolicy, + aLoadGroup, + mAcceptHeader, + requestFlags, + aContentPolicyType, + aLoadingPrincipal, + aContext, + mRespectPrivacy); + if (NS_FAILED(rv)) { + return NS_ERROR_FAILURE; + } + + MOZ_ASSERT(NS_UsePrivateBrowsing(newChannel) == mRespectPrivacy); + + NewRequestAndEntry(forcePrincipalCheck, this, key, + getter_AddRefs(request), + getter_AddRefs(entry)); + + MOZ_LOG(gImgLog, LogLevel::Debug, + ("[this=%p] imgLoader::LoadImage -- Created new imgRequest" + " [request=%p]\n", this, request.get())); + + nsCOMPtr<nsILoadGroup> channelLoadGroup; + newChannel->GetLoadGroup(getter_AddRefs(channelLoadGroup)); + rv = request->Init(aURI, aURI, /* aHadInsecureRedirect = */ false, + channelLoadGroup, newChannel, entry, aLoadingDocument, + aLoadingPrincipal, corsmode, aReferrerPolicy); + if (NS_FAILED(rv)) { + return NS_ERROR_FAILURE; + } + + // Add the initiator type for this image load + nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(newChannel); + if (timedChannel) { + timedChannel->SetInitiatorType(initiatorType); + } + + // create the proxy listener + nsCOMPtr<nsIStreamListener> listener = new ProxyListener(request.get()); + + MOZ_LOG(gImgLog, LogLevel::Debug, + ("[this=%p] imgLoader::LoadImage -- Calling channel->AsyncOpen2()\n", + this)); + + mozilla::net::PredictorLearn(aURI, aInitialDocumentURI, + nsINetworkPredictor::LEARN_LOAD_SUBRESOURCE, aLoadGroup); + + nsresult openRes = newChannel->AsyncOpen2(listener); + + if (NS_FAILED(openRes)) { + MOZ_LOG(gImgLog, LogLevel::Debug, + ("[this=%p] imgLoader::LoadImage -- AsyncOpen2() failed: 0x%x\n", + this, openRes)); + request->CancelAndAbort(openRes); + return openRes; + } + + // Try to add the new request into the cache. + PutIntoCache(key, entry); + } else { + LOG_MSG_WITH_PARAM(gImgLog, + "imgLoader::LoadImage |cache hit|", "request", request); + } + + + // If we didn't get a proxy when validating the cache entry, we need to + // create one. + if (!*_retval) { + // ValidateEntry() has three return values: "Is valid," "might be valid -- + // validating over network", and "not valid." If we don't have a _retval, + // we know ValidateEntry is not validating over the network, so it's safe + // to SetLoadId here because we know this request is valid for this context. + // + // Note, however, that this doesn't guarantee the behaviour we want (one + // URL maps to the same image on a page) if we load the same image in a + // different tab (see bug 528003), because its load id will get re-set, and + // that'll cause us to validate over the network. + request->SetLoadId(aLoadingDocument); + + LOG_MSG(gImgLog, "imgLoader::LoadImage", "creating proxy request."); + rv = CreateNewProxyForRequest(request, aLoadGroup, aObserver, + requestFlags, _retval); + if (NS_FAILED(rv)) { + return rv; + } + + imgRequestProxy* proxy = *_retval; + + // Make sure that OnStatus/OnProgress calls have the right request set, if + // we did create a channel here. + if (newChannel) { + nsCOMPtr<nsIInterfaceRequestor> requestor( + new nsProgressNotificationProxy(newChannel, proxy)); + if (!requestor) { + return NS_ERROR_OUT_OF_MEMORY; + } + newChannel->SetNotificationCallbacks(requestor); + } + + // Note that it's OK to add here even if the request is done. If it is, + // it'll send a OnStopRequest() to the proxy in imgRequestProxy::Notify and + // the proxy will be removed from the loadgroup. + proxy->AddToLoadGroup(); + + // If we're loading off the network, explicitly don't notify our proxy, + // because necko (or things called from necko, such as imgCacheValidator) + // are going to call our notifications asynchronously, and we can't make it + // further asynchronous because observers might rely on imagelib completing + // its work between the channel's OnStartRequest and OnStopRequest. + if (!newChannel) { + proxy->NotifyListener(); + } + + return rv; + } + + NS_ASSERTION(*_retval, "imgLoader::LoadImage -- no return value"); + + return NS_OK; +} + +NS_IMETHODIMP +imgLoader::LoadImageWithChannelXPCOM(nsIChannel* channel, + imgINotificationObserver* aObserver, + nsISupports* aCX, + nsIStreamListener** listener, + imgIRequest** _retval) +{ + nsresult result; + imgRequestProxy* proxy; + result = LoadImageWithChannel(channel, + aObserver, + aCX, + listener, + &proxy); + *_retval = proxy; + return result; +} + +nsresult +imgLoader::LoadImageWithChannel(nsIChannel* channel, + imgINotificationObserver* aObserver, + nsISupports* aCX, + nsIStreamListener** listener, + imgRequestProxy** _retval) +{ + NS_ASSERTION(channel, + "imgLoader::LoadImageWithChannel -- NULL channel pointer"); + + MOZ_ASSERT(NS_UsePrivateBrowsing(channel) == mRespectPrivacy); + + RefPtr<imgRequest> request; + + nsCOMPtr<nsIURI> uri; + channel->GetURI(getter_AddRefs(uri)); + nsCOMPtr<nsIDocument> doc = do_QueryInterface(aCX); + + NS_ENSURE_TRUE(channel, NS_ERROR_FAILURE); + nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); + + PrincipalOriginAttributes attrs; + if (loadInfo) { + attrs.InheritFromNecko(loadInfo->GetOriginAttributes()); + } + + nsresult rv; + ImageCacheKey key(uri, attrs, doc, rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsLoadFlags requestFlags = nsIRequest::LOAD_NORMAL; + channel->GetLoadFlags(&requestFlags); + + RefPtr<imgCacheEntry> entry; + + if (requestFlags & nsIRequest::LOAD_BYPASS_CACHE) { + RemoveFromCache(key); + } else { + // Look in the cache for our URI, and then validate it. + // XXX For now ignore aCacheKey. We will need it in the future + // for correctly dealing with image load requests that are a result + // of post data. + imgCacheTable& cache = GetCache(key); + if (cache.Get(key, getter_AddRefs(entry)) && entry) { + // We don't want to kick off another network load. So we ask + // ValidateEntry to only do validation without creating a new proxy. If + // it says that the entry isn't valid any more, we'll only use the entry + // we're getting if the channel is loading from the cache anyways. + // + // XXX -- should this be changed? it's pretty much verbatim from the old + // code, but seems nonsensical. + // + // Since aCanMakeNewChannel == false, we don't need to pass content policy + // type/principal/etc + + nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); + // if there is a loadInfo, use the right contentType, otherwise + // default to the internal image type + nsContentPolicyType policyType = loadInfo + ? loadInfo->InternalContentPolicyType() + : nsIContentPolicy::TYPE_INTERNAL_IMAGE; + + if (ValidateEntry(entry, uri, nullptr, nullptr, RP_Default, + nullptr, aObserver, aCX, requestFlags, + policyType, false, nullptr, + nullptr, imgIRequest::CORS_NONE)) { + request = entry->GetRequest(); + } else { + nsCOMPtr<nsICacheInfoChannel> cacheChan(do_QueryInterface(channel)); + bool bUseCacheCopy; + + if (cacheChan) { + cacheChan->IsFromCache(&bUseCacheCopy); + } else { + bUseCacheCopy = false; + } + + if (!bUseCacheCopy) { + entry = nullptr; + } else { + request = entry->GetRequest(); + } + } + + if (request && entry) { + // If this entry has no proxies, its request has no reference to + // the entry. + if (entry->HasNoProxies()) { + LOG_FUNC_WITH_PARAM(gImgLog, + "imgLoader::LoadImageWithChannel() adding proxyless entry", + "uri", key.Spec()); + MOZ_ASSERT(!request->HasCacheEntry(), + "Proxyless entry's request has cache entry!"); + request->SetCacheEntry(entry); + + if (mCacheTracker && entry->GetExpirationState()->IsTracked()) { + mCacheTracker->MarkUsed(entry); + } + } + } + } + } + + nsCOMPtr<nsILoadGroup> loadGroup; + channel->GetLoadGroup(getter_AddRefs(loadGroup)); + + // Filter out any load flags not from nsIRequest + requestFlags &= nsIRequest::LOAD_REQUESTMASK; + + rv = NS_OK; + if (request) { + // we have this in our cache already.. cancel the current (document) load + + // this should fire an OnStopRequest + channel->Cancel(NS_ERROR_PARSED_DATA_CACHED); + + *listener = nullptr; // give them back a null nsIStreamListener + + rv = CreateNewProxyForRequest(request, loadGroup, aObserver, + requestFlags, _retval); + static_cast<imgRequestProxy*>(*_retval)->NotifyListener(); + } else { + // We use originalURI here to fulfil the imgIRequest contract on GetURI. + nsCOMPtr<nsIURI> originalURI; + channel->GetOriginalURI(getter_AddRefs(originalURI)); + + // XXX(seth): We should be able to just use |key| here, except that |key| is + // constructed above with the *current URI* and not the *original URI*. I'm + // pretty sure this is a bug, and it's preventing us from ever getting a + // cache hit in LoadImageWithChannel when redirects are involved. + ImageCacheKey originalURIKey(originalURI, attrs, doc, rv); + NS_ENSURE_SUCCESS(rv, rv); + + // Default to doing a principal check because we don't know who + // started that load and whether their principal ended up being + // inherited on the channel. + NewRequestAndEntry(/* aForcePrincipalCheckForCacheEntry = */ true, + this, originalURIKey, + getter_AddRefs(request), + getter_AddRefs(entry)); + + // No principal specified here, because we're not passed one. + // In LoadImageWithChannel, the redirects that may have been + // assoicated with this load would have gone through necko. + // We only have the final URI in ImageLib and hence don't know + // if the request went through insecure redirects. But if it did, + // the necko cache should have handled that (since all necko cache hits + // including the redirects will go through content policy). Hence, we + // can set aHadInsecureRedirect to false here. + rv = request->Init(originalURI, uri, /* aHadInsecureRedirect = */ false, + channel, channel, entry, aCX, nullptr, + imgIRequest::CORS_NONE, RP_Default); + NS_ENSURE_SUCCESS(rv, rv); + + RefPtr<ProxyListener> pl = + new ProxyListener(static_cast<nsIStreamListener*>(request.get())); + pl.forget(listener); + + // Try to add the new request into the cache. + PutIntoCache(originalURIKey, entry); + + rv = CreateNewProxyForRequest(request, loadGroup, aObserver, + requestFlags, _retval); + + // Explicitly don't notify our proxy, because we're loading off the + // network, and necko (or things called from necko, such as + // imgCacheValidator) are going to call our notifications asynchronously, + // and we can't make it further asynchronous because observers might rely + // on imagelib completing its work between the channel's OnStartRequest and + // OnStopRequest. + } + + return rv; +} + +bool +imgLoader::SupportImageWithMimeType(const char* aMimeType, + AcceptedMimeTypes aAccept + /* = AcceptedMimeTypes::IMAGES */) +{ + nsAutoCString mimeType(aMimeType); + ToLowerCase(mimeType); + + if (aAccept == AcceptedMimeTypes::IMAGES_AND_DOCUMENTS && + mimeType.EqualsLiteral("image/svg+xml")) { + return true; + } + + DecoderType type = DecoderFactory::GetDecoderType(mimeType.get()); + return type != DecoderType::UNKNOWN; +} + +NS_IMETHODIMP +imgLoader::GetMIMETypeFromContent(nsIRequest* aRequest, + const uint8_t* aContents, + uint32_t aLength, + nsACString& aContentType) +{ + return GetMimeTypeFromContent((const char*)aContents, aLength, aContentType); +} + +/* static */ +nsresult +imgLoader::GetMimeTypeFromContent(const char* aContents, + uint32_t aLength, + nsACString& aContentType) +{ + /* Is it a GIF? */ + if (aLength >= 6 && (!nsCRT::strncmp(aContents, "GIF87a", 6) || + !nsCRT::strncmp(aContents, "GIF89a", 6))) { + aContentType.AssignLiteral(IMAGE_GIF); + + /* or a PNG? */ + } else if (aLength >= 8 && ((unsigned char)aContents[0]==0x89 && + (unsigned char)aContents[1]==0x50 && + (unsigned char)aContents[2]==0x4E && + (unsigned char)aContents[3]==0x47 && + (unsigned char)aContents[4]==0x0D && + (unsigned char)aContents[5]==0x0A && + (unsigned char)aContents[6]==0x1A && + (unsigned char)aContents[7]==0x0A)) { + aContentType.AssignLiteral(IMAGE_PNG); + + /* maybe a JPEG (JFIF)? */ + /* JFIF files start with SOI APP0 but older files can start with SOI DQT + * so we test for SOI followed by any marker, i.e. FF D8 FF + * this will also work for SPIFF JPEG files if they appear in the future. + * + * (JFIF is 0XFF 0XD8 0XFF 0XE0 <skip 2> 0X4A 0X46 0X49 0X46 0X00) + */ + } else if (aLength >= 3 && + ((unsigned char)aContents[0])==0xFF && + ((unsigned char)aContents[1])==0xD8 && + ((unsigned char)aContents[2])==0xFF) { + aContentType.AssignLiteral(IMAGE_JPEG); + + /* or how about ART? */ + /* ART begins with JG (4A 47). Major version offset 2. + * Minor version offset 3. Offset 4 must be nullptr. + */ + } else if (aLength >= 5 && + ((unsigned char) aContents[0])==0x4a && + ((unsigned char) aContents[1])==0x47 && + ((unsigned char) aContents[4])==0x00 ) { + aContentType.AssignLiteral(IMAGE_ART); + + } else if (aLength >= 2 && !nsCRT::strncmp(aContents, "BM", 2)) { + aContentType.AssignLiteral(IMAGE_BMP); + + // ICOs always begin with a 2-byte 0 followed by a 2-byte 1. + // CURs begin with 2-byte 0 followed by 2-byte 2. + } else if (aLength >= 4 && (!memcmp(aContents, "\000\000\001\000", 4) || + !memcmp(aContents, "\000\000\002\000", 4))) { + aContentType.AssignLiteral(IMAGE_ICO); + + } else { + /* none of the above? I give up */ + return NS_ERROR_NOT_AVAILABLE; + } + + return NS_OK; +} + +/** + * proxy stream listener class used to handle multipart/x-mixed-replace + */ + +#include "nsIRequest.h" +#include "nsIStreamConverterService.h" + +NS_IMPL_ISUPPORTS(ProxyListener, + nsIStreamListener, + nsIThreadRetargetableStreamListener, + nsIRequestObserver) + +ProxyListener::ProxyListener(nsIStreamListener* dest) : + mDestListener(dest) +{ + /* member initializers and constructor code */ +} + +ProxyListener::~ProxyListener() +{ + /* destructor code */ +} + + +/** nsIRequestObserver methods **/ + +NS_IMETHODIMP +ProxyListener::OnStartRequest(nsIRequest* aRequest, nsISupports* ctxt) +{ + if (!mDestListener) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest)); + if (channel) { + // We need to set the initiator type for the image load + nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(channel); + if (timedChannel) { + nsAutoString type; + timedChannel->GetInitiatorType(type); + if (type.IsEmpty()) { + timedChannel->SetInitiatorType(NS_LITERAL_STRING("img")); + } + } + + nsAutoCString contentType; + nsresult rv = channel->GetContentType(contentType); + + if (!contentType.IsEmpty()) { + /* If multipart/x-mixed-replace content, we'll insert a MIME decoder + in the pipeline to handle the content and pass it along to our + original listener. + */ + if (NS_LITERAL_CSTRING("multipart/x-mixed-replace").Equals(contentType)) { + + nsCOMPtr<nsIStreamConverterService> convServ( + do_GetService("@mozilla.org/streamConverters;1", &rv)); + if (NS_SUCCEEDED(rv)) { + nsCOMPtr<nsIStreamListener> toListener(mDestListener); + nsCOMPtr<nsIStreamListener> fromListener; + + rv = convServ->AsyncConvertData("multipart/x-mixed-replace", + "*/*", + toListener, + nullptr, + getter_AddRefs(fromListener)); + if (NS_SUCCEEDED(rv)) { + mDestListener = fromListener; + } + } + } + } + } + + return mDestListener->OnStartRequest(aRequest, ctxt); +} + +NS_IMETHODIMP +ProxyListener::OnStopRequest(nsIRequest* aRequest, + nsISupports* ctxt, + nsresult status) +{ + if (!mDestListener) { + return NS_ERROR_FAILURE; + } + + return mDestListener->OnStopRequest(aRequest, ctxt, status); +} + +/** nsIStreamListener methods **/ + +NS_IMETHODIMP +ProxyListener::OnDataAvailable(nsIRequest* aRequest, nsISupports* ctxt, + nsIInputStream* inStr, uint64_t sourceOffset, + uint32_t count) +{ + if (!mDestListener) { + return NS_ERROR_FAILURE; + } + + return mDestListener->OnDataAvailable(aRequest, ctxt, inStr, + sourceOffset, count); +} + +/** nsThreadRetargetableStreamListener methods **/ +NS_IMETHODIMP +ProxyListener::CheckListenerChain() +{ + NS_ASSERTION(NS_IsMainThread(), "Should be on the main thread!"); + nsresult rv = NS_OK; + nsCOMPtr<nsIThreadRetargetableStreamListener> retargetableListener = + do_QueryInterface(mDestListener, &rv); + if (retargetableListener) { + rv = retargetableListener->CheckListenerChain(); + } + MOZ_LOG(gImgLog, LogLevel::Debug, + ("ProxyListener::CheckListenerChain %s [this=%p listener=%p rv=%x]", + (NS_SUCCEEDED(rv) ? "success" : "failure"), + this, (nsIStreamListener*)mDestListener, rv)); + return rv; +} + +/** + * http validate class. check a channel for a 304 + */ + +NS_IMPL_ISUPPORTS(imgCacheValidator, nsIStreamListener, nsIRequestObserver, + nsIThreadRetargetableStreamListener, + nsIChannelEventSink, nsIInterfaceRequestor, + nsIAsyncVerifyRedirectCallback) + +imgCacheValidator::imgCacheValidator(nsProgressNotificationProxy* progress, + imgLoader* loader, imgRequest* request, + nsISupports* aContext, + bool forcePrincipalCheckForCacheEntry) + : mProgressProxy(progress), + mRequest(request), + mContext(aContext), + mImgLoader(loader), + mHadInsecureRedirect(false) +{ + NewRequestAndEntry(forcePrincipalCheckForCacheEntry, loader, + mRequest->CacheKey(), + getter_AddRefs(mNewRequest), + getter_AddRefs(mNewEntry)); +} + +imgCacheValidator::~imgCacheValidator() +{ + if (mRequest) { + mRequest->SetValidator(nullptr); + } +} + +void +imgCacheValidator::AddProxy(imgRequestProxy* aProxy) +{ + // aProxy needs to be in the loadgroup since we're validating from + // the network. + aProxy->AddToLoadGroup(); + + mProxies.AppendObject(aProxy); +} + +/** nsIRequestObserver methods **/ + +NS_IMETHODIMP +imgCacheValidator::OnStartRequest(nsIRequest* aRequest, nsISupports* ctxt) +{ + // We may be holding on to a document, so ensure that it's released. + nsCOMPtr<nsISupports> context = mContext.forget(); + + // If for some reason we don't still have an existing request (probably + // because OnStartRequest got delivered more than once), just bail. + if (!mRequest) { + MOZ_ASSERT_UNREACHABLE("OnStartRequest delivered more than once?"); + aRequest->Cancel(NS_BINDING_ABORTED); + return NS_ERROR_FAILURE; + } + + // If this request is coming from cache and has the same URI as our + // imgRequest, the request all our proxies are pointing at is valid, and all + // we have to do is tell them to notify their listeners. + nsCOMPtr<nsICacheInfoChannel> cacheChan(do_QueryInterface(aRequest)); + nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest)); + if (cacheChan && channel && !mRequest->CacheChanged(aRequest)) { + bool isFromCache = false; + cacheChan->IsFromCache(&isFromCache); + + nsCOMPtr<nsIURI> channelURI; + channel->GetURI(getter_AddRefs(channelURI)); + + nsCOMPtr<nsIURI> currentURI; + mRequest->GetCurrentURI(getter_AddRefs(currentURI)); + + bool sameURI = false; + if (channelURI && currentURI) { + channelURI->Equals(currentURI, &sameURI); + } + + if (isFromCache && sameURI) { + uint32_t count = mProxies.Count(); + for (int32_t i = count-1; i>=0; i--) { + imgRequestProxy* proxy = static_cast<imgRequestProxy*>(mProxies[i]); + + // Proxies waiting on cache validation should be deferring + // notifications. Undefer them. + MOZ_ASSERT(proxy->NotificationsDeferred(), + "Proxies waiting on cache validation should be " + "deferring notifications!"); + proxy->SetNotificationsDeferred(false); + + // Notify synchronously, because we're already in OnStartRequest, an + // asynchronously-called function. + proxy->SyncNotifyListener(); + } + + // We don't need to load this any more. + aRequest->Cancel(NS_BINDING_ABORTED); + + mRequest->SetLoadId(context); + mRequest->SetValidator(nullptr); + + mRequest = nullptr; + + mNewRequest = nullptr; + mNewEntry = nullptr; + + return NS_OK; + } + } + + // We can't load out of cache. We have to create a whole new request for the + // data that's coming in off the channel. + nsCOMPtr<nsIURI> uri; + { + RefPtr<ImageURL> imageURL; + mRequest->GetURI(getter_AddRefs(imageURL)); + uri = imageURL->ToIURI(); + } + + if (MOZ_LOG_TEST(gImgLog, LogLevel::Debug)) { + LOG_MSG_WITH_PARAM(gImgLog, + "imgCacheValidator::OnStartRequest creating new request", + "uri", uri->GetSpecOrDefault().get()); + } + + int32_t corsmode = mRequest->GetCORSMode(); + ReferrerPolicy refpol = mRequest->GetReferrerPolicy(); + nsCOMPtr<nsIPrincipal> loadingPrincipal = mRequest->GetLoadingPrincipal(); + + // Doom the old request's cache entry + mRequest->RemoveFromCache(); + + mRequest->SetValidator(nullptr); + mRequest = nullptr; + + // We use originalURI here to fulfil the imgIRequest contract on GetURI. + nsCOMPtr<nsIURI> originalURI; + channel->GetOriginalURI(getter_AddRefs(originalURI)); + nsresult rv = + mNewRequest->Init(originalURI, uri, mHadInsecureRedirect, aRequest, channel, + mNewEntry, context, loadingPrincipal, corsmode, refpol); + if (NS_FAILED(rv)) { + return rv; + } + + mDestListener = new ProxyListener(mNewRequest); + + // Try to add the new request into the cache. Note that the entry must be in + // the cache before the proxies' ownership changes, because adding a proxy + // changes the caching behaviour for imgRequests. + mImgLoader->PutIntoCache(mNewRequest->CacheKey(), mNewEntry); + + uint32_t count = mProxies.Count(); + for (int32_t i = count-1; i>=0; i--) { + imgRequestProxy* proxy = static_cast<imgRequestProxy*>(mProxies[i]); + proxy->ChangeOwner(mNewRequest); + + // Notify synchronously, because we're already in OnStartRequest, an + // asynchronously-called function. + proxy->SetNotificationsDeferred(false); + proxy->SyncNotifyListener(); + } + + mNewRequest = nullptr; + mNewEntry = nullptr; + + return mDestListener->OnStartRequest(aRequest, ctxt); +} + +NS_IMETHODIMP +imgCacheValidator::OnStopRequest(nsIRequest* aRequest, + nsISupports* ctxt, + nsresult status) +{ + // Be sure we've released the document that we may have been holding on to. + mContext = nullptr; + + if (!mDestListener) { + return NS_OK; + } + + return mDestListener->OnStopRequest(aRequest, ctxt, status); +} + +/** nsIStreamListener methods **/ + + +NS_IMETHODIMP +imgCacheValidator::OnDataAvailable(nsIRequest* aRequest, nsISupports* ctxt, + nsIInputStream* inStr, + uint64_t sourceOffset, uint32_t count) +{ + if (!mDestListener) { + // XXX see bug 113959 + uint32_t _retval; + inStr->ReadSegments(NS_DiscardSegment, nullptr, count, &_retval); + return NS_OK; + } + + return mDestListener->OnDataAvailable(aRequest, ctxt, inStr, sourceOffset, + count); +} + +/** nsIThreadRetargetableStreamListener methods **/ + +NS_IMETHODIMP +imgCacheValidator::CheckListenerChain() +{ + NS_ASSERTION(NS_IsMainThread(), "Should be on the main thread!"); + nsresult rv = NS_OK; + nsCOMPtr<nsIThreadRetargetableStreamListener> retargetableListener = + do_QueryInterface(mDestListener, &rv); + if (retargetableListener) { + rv = retargetableListener->CheckListenerChain(); + } + MOZ_LOG(gImgLog, LogLevel::Debug, + ("[this=%p] imgCacheValidator::CheckListenerChain -- rv %d=%s", + this, NS_SUCCEEDED(rv) ? "succeeded" : "failed", rv)); + return rv; +} + +/** nsIInterfaceRequestor methods **/ + +NS_IMETHODIMP +imgCacheValidator::GetInterface(const nsIID& aIID, void** aResult) +{ + if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) { + return QueryInterface(aIID, aResult); + } + + return mProgressProxy->GetInterface(aIID, aResult); +} + +// These functions are materially the same as the same functions in imgRequest. +// We duplicate them because we're verifying whether cache loads are necessary, +// not unconditionally loading. + +/** nsIChannelEventSink methods **/ +NS_IMETHODIMP +imgCacheValidator:: + AsyncOnChannelRedirect(nsIChannel* oldChannel, + nsIChannel* newChannel, + uint32_t flags, + nsIAsyncVerifyRedirectCallback* callback) +{ + // Note all cache information we get from the old channel. + mNewRequest->SetCacheValidation(mNewEntry, oldChannel); + + // If the previous URI is a non-HTTPS URI, record that fact for later use by + // security code, which needs to know whether there is an insecure load at any + // point in the redirect chain. + nsCOMPtr<nsIURI> oldURI; + bool isHttps = false; + bool isChrome = false; + bool schemeLocal = false; + if (NS_FAILED(oldChannel->GetURI(getter_AddRefs(oldURI))) || + NS_FAILED(oldURI->SchemeIs("https", &isHttps)) || + NS_FAILED(oldURI->SchemeIs("chrome", &isChrome)) || + NS_FAILED(NS_URIChainHasFlags(oldURI, + nsIProtocolHandler::URI_IS_LOCAL_RESOURCE, + &schemeLocal)) || + (!isHttps && !isChrome && !schemeLocal)) { + mHadInsecureRedirect = true; + } + + // Prepare for callback + mRedirectCallback = callback; + mRedirectChannel = newChannel; + + return mProgressProxy->AsyncOnChannelRedirect(oldChannel, newChannel, flags, + this); +} + +NS_IMETHODIMP +imgCacheValidator::OnRedirectVerifyCallback(nsresult aResult) +{ + // If we've already been told to abort, just do so. + if (NS_FAILED(aResult)) { + mRedirectCallback->OnRedirectVerifyCallback(aResult); + mRedirectCallback = nullptr; + mRedirectChannel = nullptr; + return NS_OK; + } + + // make sure we have a protocol that returns data rather than opens + // an external application, e.g. mailto: + nsCOMPtr<nsIURI> uri; + mRedirectChannel->GetURI(getter_AddRefs(uri)); + bool doesNotReturnData = false; + NS_URIChainHasFlags(uri, nsIProtocolHandler::URI_DOES_NOT_RETURN_DATA, + &doesNotReturnData); + + nsresult result = NS_OK; + + if (doesNotReturnData) { + result = NS_ERROR_ABORT; + } + + mRedirectCallback->OnRedirectVerifyCallback(result); + mRedirectCallback = nullptr; + mRedirectChannel = nullptr; + return NS_OK; +} |