Source code

Revision control

Copy as Markdown

Other Tools

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* 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 */
#ifndef mozilla_image_imgLoader_h
#define mozilla_image_imgLoader_h
#include "mozilla/Attributes.h"
#include "mozilla/CORSMode.h"
#include "mozilla/Mutex.h"
#include "mozilla/EnumSet.h"
#include "mozilla/UniquePtr.h"
#include "imgILoader.h"
#include "imgICache.h"
#include "nsWeakReference.h"
#include "nsIContentSniffer.h"
#include "nsRefPtrHashtable.h"
#include "nsTHashSet.h"
#include "nsExpirationTracker.h"
#include "ImageCacheKey.h"
#include "imgRequest.h"
#include "nsIProgressEventSink.h"
#include "nsIChannel.h"
#include "nsIThreadRetargetableStreamListener.h"
#include "imgIRequest.h"
class imgLoader;
class imgRequestProxy;
class imgINotificationObserver;
class nsILoadGroup;
class imgCacheExpirationTracker;
class imgMemoryReporter;
namespace mozilla {
namespace dom {
class Document;
} // namespace mozilla
class imgCacheEntry {
imgCacheEntry(imgLoader* loader, imgRequest* request,
bool aForcePrincipalCheck);
uint32_t GetDataSize() const { return mDataSize; }
void SetDataSize(uint32_t aDataSize) {
int32_t oldsize = mDataSize;
mDataSize = aDataSize;
UpdateCache(mDataSize - oldsize);
int32_t GetTouchedTime() const { return mTouchedTime; }
void SetTouchedTime(int32_t time) {
mTouchedTime = time;
Touch(/* updateTime = */ false);
uint32_t GetLoadTime() const { return mLoadTime; }
void UpdateLoadTime();
uint32_t GetExpiryTime() const { return mExpiryTime; }
void SetExpiryTime(uint32_t aExpiryTime) {
mExpiryTime = aExpiryTime;
bool GetMustValidate() const { return mMustValidate; }
void SetMustValidate(bool aValidate) {
mMustValidate = aValidate;
already_AddRefed<imgRequest> GetRequest() const {
RefPtr<imgRequest> req = mRequest;
return req.forget();
bool Evicted() const { return mEvicted; }
nsExpirationState* GetExpirationState() { return &mExpirationState; }
bool HasNoProxies() const { return mHasNoProxies; }
bool ForcePrincipalCheck() const { return mForcePrincipalCheck; }
bool HasNotified() const { return mHasNotified; }
void SetHasNotified() {
mHasNotified = true;
imgLoader* Loader() const { return mLoader; }
private: // methods
friend class imgLoader;
friend class imgCacheQueue;
void Touch(bool updateTime = true);
void UpdateCache(int32_t diff = 0);
void SetEvicted(bool evict) { mEvicted = evict; }
void SetHasNoProxies(bool hasNoProxies);
// Private, unimplemented copy constructor.
imgCacheEntry(const imgCacheEntry&);
private: // data
imgLoader* mLoader;
RefPtr<imgRequest> mRequest;
uint32_t mDataSize;
int32_t mTouchedTime;
uint32_t mLoadTime;
uint32_t mExpiryTime;
nsExpirationState mExpirationState;
bool mMustValidate : 1;
bool mEvicted : 1;
bool mHasNoProxies : 1;
bool mForcePrincipalCheck : 1;
bool mHasNotified : 1;
#include <vector>
{ /* c1354898-e3fe-4602-88a7-c4520c21cb4e */ \
0xc1354898, 0xe3fe, 0x4602, { \
0x88, 0xa7, 0xc4, 0x52, 0x0c, 0x21, 0xcb, 0x4e \
} \
class imgCacheQueue {
void Remove(imgCacheEntry*);
void Push(imgCacheEntry*);
void MarkDirty();
bool IsDirty();
already_AddRefed<imgCacheEntry> Pop();
void Refresh();
uint32_t GetSize() const;
void UpdateSize(int32_t diff);
uint32_t GetNumElements() const;
bool Contains(imgCacheEntry* aEntry) const;
typedef nsTArray<RefPtr<imgCacheEntry>> queueContainer;
typedef queueContainer::iterator iterator;
typedef queueContainer::const_iterator const_iterator;
iterator begin();
const_iterator begin() const;
iterator end();
const_iterator end() const;
queueContainer mQueue;
bool mDirty;
uint32_t mSize;
enum class AcceptedMimeTypes : uint8_t {
class imgLoader final : public imgILoader,
public nsIContentSniffer,
public imgICache,
public nsSupportsWeakReference,
public nsIObserver {
virtual ~imgLoader();
using ImageCacheKey = mozilla::image::ImageCacheKey;
using imgCacheTable =
nsRefPtrHashtable<nsGenericHashKey<ImageCacheKey>, imgCacheEntry>;
using imgSet = nsTHashSet<imgRequest*>;
using Mutex = mozilla::Mutex;
* Get the normal image loader instance that is used by gecko code, creating
* it if necessary.
static imgLoader* NormalLoader();
* Get the Private Browsing image loader instance that is used by gecko code,
* creating it if necessary.
static imgLoader* PrivateBrowsingLoader();
* Gecko code should use NormalLoader() or PrivateBrowsingLoader() to get the
* appropriate image loader.
* This constructor is public because the XPCOM module code that creates
* instances of ";1" / ";1"
* for nsIComponentManager.createInstance()/nsIServiceManager.getService()
* calls (now only made by add-ons) needs access to it.
* XXX We would like to get rid of the nsIServiceManager.getService (and
* nsIComponentManager.createInstance) method of creating imgLoader objects,
* but there are add-ons that are still using it. These add-ons don't
* actually do anything useful with the loaders that they create since nobody
* who creates an imgLoader using this method actually QIs to imgILoader and
* loads images. They all just QI to imgICache and either call clearCache()
* or findEntryProperties(). Since they're doing this on an imgLoader that
* has never loaded images, these calls are useless. It seems likely that
* the code that is doing this is just legacy code left over from a time when
* there was only one imgLoader instance for the entire process. (Nowadays
* the correct method to get an imgILoader/imgICache is to call
* imgITools::getImgCacheForDocument/imgITools::getImgLoaderForDocument.)
* All the same, even though what these add-ons are doing is a no-op,
* removing the nsIServiceManager.getService method of creating/getting an
* imgLoader objects would cause an exception in these add-ons that could
* break things.
nsresult Init();
bool IsImageAvailable(nsIURI*, nsIPrincipal* aTriggeringPrincipal,
mozilla::CORSMode, mozilla::dom::Document*);
[[nodiscard]] nsresult LoadImage(
nsIURI* aURI, nsIURI* aInitialDocumentURI, nsIReferrerInfo* aReferrerInfo,
nsIPrincipal* aLoadingPrincipal, uint64_t aRequestContextID,
nsILoadGroup* aLoadGroup, imgINotificationObserver* aObserver,
nsINode* aContext, mozilla::dom::Document* aLoadingDocument,
nsLoadFlags aLoadFlags, nsISupports* aCacheKey,
nsContentPolicyType aContentPolicyType, const nsAString& initiatorType,
bool aUseUrgentStartForChannel, bool aLinkPreload,
uint64_t aEarlyHintPreloaderId, imgRequestProxy** _retval);
[[nodiscard]] nsresult LoadImageWithChannel(
nsIChannel* channel, imgINotificationObserver* aObserver,
mozilla::dom::Document* aLoadingDocument, nsIStreamListener** listener,
imgRequestProxy** _retval);
static nsresult GetMimeTypeFromContent(const char* aContents,
uint32_t aLength,
nsACString& aContentType);
* Returns true if the given mime type may be interpreted as an image.
* Some MIME types may be interpreted as both images and documents. (At the
* moment only "image/svg+xml" falls into this category, but there may be more
* in the future.) Callers which want this function to return true for such
* MIME types should pass AcceptedMimeTypes::IMAGES_AND_DOCUMENTS for
* @aAccept.
* @param aMimeType The MIME type to evaluate.
* @param aAcceptedMimeTypes Which kinds of MIME types to treat as images.
static bool SupportImageWithMimeType(
const nsACString&, AcceptedMimeTypes aAccept = AcceptedMimeTypes::IMAGES);
static void GlobalInit(); // for use by the factory
static void Shutdown(); // for use by the factory
static void ShutdownMemoryReporter();
enum class ClearOption {
using ClearOptions = mozilla::EnumSet<ClearOption>;
nsresult ClearImageCache(ClearOptions = {});
void MinimizeCache() { ClearImageCache({ClearOption::UnusedOnly}); }
nsresult InitCache();
bool RemoveFromCache(const ImageCacheKey& aKey);
// Enumeration describing if a given entry is in the cache queue or not.
// There are some cases we know the entry is definitely not in the queue.
enum class QueueState { MaybeExists, AlreadyRemoved };
bool RemoveFromCache(imgCacheEntry* entry,
QueueState aQueueState = QueueState::MaybeExists);
bool PutIntoCache(const ImageCacheKey& aKey, imgCacheEntry* aEntry);
void AddToUncachedImages(imgRequest* aRequest);
void RemoveFromUncachedImages(imgRequest* aRequest);
// Returns true if we should prefer evicting cache entry |two| over cache
// entry |one|.
// This mixes units in the worst way, but provides reasonable results.
inline static bool CompareCacheEntries(const RefPtr<imgCacheEntry>& one,
const RefPtr<imgCacheEntry>& two) {
if (!one) {
return false;
if (!two) {
return true;
const double sizeweight = 1.0 - sCacheTimeWeight;
// We want large, old images to be evicted first (depending on their
// relative weights). Since a larger time is actually newer, we subtract
// time's weight, so an older image has a larger weight.
double oneweight = double(one->GetDataSize()) * sizeweight -
double(one->GetTouchedTime()) * sCacheTimeWeight;
double twoweight = double(two->GetDataSize()) * sizeweight -
double(two->GetTouchedTime()) * sCacheTimeWeight;
return oneweight < twoweight;
void VerifyCacheSizes();
nsresult RemoveEntriesInternal(nsIPrincipal* aPrincipal,
const nsACString* aBaseDomain);
// The image loader maintains a hash table of all imgCacheEntries. However,
// only some of them will be evicted from the cache: those who have no
// imgRequestProxies watching their imgRequests.
// Once an imgRequest has no imgRequestProxies, it should notify us by
// calling HasNoObservers(), and null out its cache entry pointer.
// Upon having a proxy start observing again, it should notify us by calling
// HasObservers(). The request's cache entry will be re-set before this
// happens, by calling imgRequest::SetCacheEntry() when an entry with no
// observers is re-requested.
bool SetHasNoProxies(imgRequest* aRequest, imgCacheEntry* aEntry);
bool SetHasProxies(imgRequest* aRequest);
private: // methods
static already_AddRefed<imgLoader> CreateImageLoader();
bool ValidateEntry(imgCacheEntry* aEntry, nsIURI* aURI,
nsIURI* aInitialDocumentURI,
nsIReferrerInfo* aReferrerInfo, nsILoadGroup* aLoadGroup,
imgINotificationObserver* aObserver,
mozilla::dom::Document* aLoadingDocument,
nsLoadFlags aLoadFlags,
nsContentPolicyType aLoadPolicyType,
bool aCanMakeNewChannel, bool* aNewChannelCreated,
imgRequestProxy** aProxyRequest,
nsIPrincipal* aTriggeringPrincipal, mozilla::CORSMode,
bool aLinkPreload, uint64_t aEarlyHintPreloaderId);
bool ValidateRequestWithNewChannel(
imgRequest* request, nsIURI* aURI, nsIURI* aInitialDocumentURI,
nsIReferrerInfo* aReferrerInfo, nsILoadGroup* aLoadGroup,
imgINotificationObserver* aObserver,
mozilla::dom::Document* aLoadingDocument, uint64_t aInnerWindowId,
nsLoadFlags aLoadFlags, nsContentPolicyType aContentPolicyType,
imgRequestProxy** aProxyRequest, nsIPrincipal* aLoadingPrincipal,
mozilla::CORSMode, bool aLinkPreload, uint64_t aEarlyHintPreloaderId,
bool* aNewChannelCreated);
void NotifyObserversForCachedImage(imgCacheEntry* aEntry, imgRequest* request,
nsIReferrerInfo* aReferrerInfo,
mozilla::dom::Document* aLoadingDocument,
nsIPrincipal* aLoadingPrincipal,
uint64_t aEarlyHintPreloaderId);
// aURI may be different from imgRequest's URI in the case of blob URIs, as we
// can share requests with different URIs.
nsresult CreateNewProxyForRequest(imgRequest* aRequest, nsIURI* aURI,
nsILoadGroup* aLoadGroup,
mozilla::dom::Document* aLoadingDocument,
imgINotificationObserver* aObserver,
nsLoadFlags aLoadFlags,
imgRequestProxy** _retval);
nsresult EvictEntries(bool aChromeOnly);
void CacheEntriesChanged(int32_t aSizeDiff);
void CheckCacheLimits();
private: // data
friend class imgCacheEntry;
friend class imgMemoryReporter;
imgCacheTable mCache;
imgCacheQueue mCacheQueue;
// Hash set of every imgRequest for this loader that isn't in mCache or
// mChromeCache. The union over all imgLoader's of mCache, mChromeCache, and
// mUncachedImages should be every imgRequest that is alive. These are weak
// pointers so we rely on the imgRequest destructor to remove itself.
imgSet mUncachedImages MOZ_GUARDED_BY(mUncachedImagesMutex);
// The imgRequest can have refs to them held on non-main thread, so we need
// a mutex because we modify the uncached images set from the imgRequest
// destructor.
Mutex mUncachedImagesMutex;
static double sCacheTimeWeight;
static uint32_t sCacheMaxSize;
static imgMemoryReporter* sMemReporter;
mozilla::UniquePtr<imgCacheExpirationTracker> mCacheTracker;
bool mRespectPrivacy;
* proxy stream listener class used to handle multipart/x-mixed-replace
#include "nsCOMPtr.h"
#include "nsIStreamListener.h"
#include "nsIThreadRetargetableStreamListener.h"
class ProxyListener : public nsIThreadRetargetableStreamListener {
explicit ProxyListener(nsIStreamListener* dest);
/* additional members */
virtual ~ProxyListener();
nsCOMPtr<nsIStreamListener> mDestListener;
* A class that implements nsIProgressEventSink and forwards all calls to it to
* the original notification callbacks of the channel. Also implements
* nsIInterfaceRequestor and gives out itself for nsIProgressEventSink calls,
* and forwards everything else to the channel's notification callbacks.
class nsProgressNotificationProxy final : public nsIProgressEventSink,
public nsIChannelEventSink,
public nsIInterfaceRequestor {
nsProgressNotificationProxy(nsIChannel* channel, imgIRequest* proxy)
: mImageRequest(proxy) {
~nsProgressNotificationProxy() = default;
nsCOMPtr<nsIInterfaceRequestor> mOriginalCallbacks;
nsCOMPtr<nsIRequest> mImageRequest;
* validate checker
#include "nsCOMArray.h"
class imgCacheValidator : public nsIThreadRetargetableStreamListener,
public nsIChannelEventSink,
public nsIInterfaceRequestor,
public nsIAsyncVerifyRedirectCallback {
imgCacheValidator(nsProgressNotificationProxy* progress, imgLoader* loader,
imgRequest* aRequest, mozilla::dom::Document* aDocument,
uint64_t aInnerWindowId,
bool forcePrincipalCheckForCacheEntry);
void AddProxy(imgRequestProxy* aProxy);
void RemoveProxy(imgRequestProxy* aProxy);
void UpdateProxies(bool aCancelRequest, bool aSyncNotify);
virtual ~imgCacheValidator();
nsCOMPtr<nsIStreamListener> mDestListener;
RefPtr<nsProgressNotificationProxy> mProgressProxy;
nsCOMPtr<nsIAsyncVerifyRedirectCallback> mRedirectCallback;
nsCOMPtr<nsIChannel> mRedirectChannel;
RefPtr<imgRequest> mRequest;
AutoTArray<RefPtr<imgRequestProxy>, 4> mProxies;
RefPtr<imgRequest> mNewRequest;
RefPtr<imgCacheEntry> mNewEntry;
RefPtr<mozilla::dom::Document> mDocument;
uint64_t mInnerWindowId;
imgLoader* mImgLoader;
bool mHadInsecureRedirect;
#endif // mozilla_image_imgLoader_h