/* -*- 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 http://mozilla.org/MPL/2.0/. */ #ifndef mozilla_image_imgLoader_h #define mozilla_image_imgLoader_h #include "mozilla/Attributes.h" #include "mozilla/Mutex.h" #include "mozilla/UniquePtr.h" #include "imgILoader.h" #include "imgICache.h" #include "nsWeakReference.h" #include "nsIContentSniffer.h" #include "nsRefPtrHashtable.h" #include "nsExpirationTracker.h" #include "ImageCacheKey.h" #include "imgRequest.h" #include "nsIProgressEventSink.h" #include "nsIChannel.h" #include "nsIThreadRetargetableStreamListener.h" #include "imgIRequest.h" #include "mozilla/net/ReferrerPolicy.h" class imgLoader; class imgRequestProxy; class imgINotificationObserver; class nsILoadGroup; class imgCacheExpirationTracker; class imgMemoryReporter; namespace mozilla { namespace image { class ImageURL; } // namespace image } // namespace mozilla class imgCacheEntry { public: imgCacheEntry(imgLoader* loader, imgRequest* request, bool aForcePrincipalCheck); ~imgCacheEntry(); nsrefcnt AddRef() { NS_PRECONDITION(int32_t(mRefCnt) >= 0, "illegal refcnt"); MOZ_ASSERT(_mOwningThread.GetThread() == PR_GetCurrentThread(), "imgCacheEntry addref isn't thread-safe!"); ++mRefCnt; NS_LOG_ADDREF(this, mRefCnt, "imgCacheEntry", sizeof(*this)); return mRefCnt; } nsrefcnt Release() { NS_PRECONDITION(0 != mRefCnt, "dup release"); MOZ_ASSERT(_mOwningThread.GetThread() == PR_GetCurrentThread(), "imgCacheEntry release isn't thread-safe!"); --mRefCnt; NS_LOG_RELEASE(this, mRefCnt, "imgCacheEntry"); if (mRefCnt == 0) { mRefCnt = 1; /* stabilize */ delete this; return 0; } return mRefCnt; } 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(); int32_t GetExpiryTime() const { return mExpiryTime; } void SetExpiryTime(int32_t aExpiryTime) { mExpiryTime = aExpiryTime; Touch(); } bool GetMustValidate() const { return mMustValidate; } void SetMustValidate(bool aValidate) { mMustValidate = aValidate; Touch(); } 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; } 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 nsAutoRefCnt mRefCnt; NS_DECL_OWNINGTHREAD imgLoader* mLoader; RefPtr<imgRequest> mRequest; uint32_t mDataSize; int32_t mTouchedTime; uint32_t mLoadTime; int32_t mExpiryTime; nsExpirationState mExpirationState; bool mMustValidate : 1; bool mEvicted : 1; bool mHasNoProxies : 1; bool mForcePrincipalCheck : 1; }; #include <vector> #define NS_IMGLOADER_CID \ { /* c1354898-e3fe-4602-88a7-c4520c21cb4e */ \ 0xc1354898, \ 0xe3fe, \ 0x4602, \ {0x88, 0xa7, 0xc4, 0x52, 0x0c, 0x21, 0xcb, 0x4e} \ } class imgCacheQueue { public: 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; typedef std::vector<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; private: queueContainer mQueue; bool mDirty; uint32_t mSize; }; enum class AcceptedMimeTypes : uint8_t { IMAGES, IMAGES_AND_DOCUMENTS, }; class imgLoader final : public imgILoader, public nsIContentSniffer, public imgICache, public nsSupportsWeakReference, public nsIObserver { virtual ~imgLoader(); public: typedef mozilla::image::ImageCacheKey ImageCacheKey; typedef mozilla::image::ImageURL ImageURL; typedef nsRefPtrHashtable<nsGenericHashKey<ImageCacheKey>, imgCacheEntry> imgCacheTable; typedef nsTHashtable<nsPtrHashKey<imgRequest>> imgSet; typedef mozilla::net::ReferrerPolicy ReferrerPolicy; typedef mozilla::Mutex Mutex; NS_DECL_ISUPPORTS NS_DECL_IMGILOADER NS_DECL_NSICONTENTSNIFFER NS_DECL_IMGICACHE NS_DECL_NSIOBSERVER /** * 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 "@mozilla.org/image/loader;1" / "@mozilla.org/image/cache;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. */ imgLoader(); nsresult Init(); MOZ_MUST_USE nsresult 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); MOZ_MUST_USE nsresult LoadImageWithChannel(nsIChannel* channel, imgINotificationObserver* aObserver, nsISupports* aCX, 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 char* aMimeType, AcceptedMimeTypes aAccept = AcceptedMimeTypes::IMAGES); static void GlobalInit(); // for use by the factory static void Shutdown(); // for use by the factory static void ShutdownMemoryReporter(); nsresult ClearChromeImageCache(); nsresult ClearImageCache(); void MinimizeCaches(); nsresult InitCache(); bool RemoveFromCache(const ImageCacheKey& aKey); bool RemoveFromCache(imgCacheEntry* entry); 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(); // 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* aKey, nsIURI* aInitialDocumentURI, nsIURI* aReferrerURI, ReferrerPolicy aReferrerPolicy, nsILoadGroup* aLoadGroup, imgINotificationObserver* aObserver, nsISupports* aCX, nsLoadFlags aLoadFlags, nsContentPolicyType aContentPolicyType, bool aCanMakeNewChannel, imgRequestProxy** aProxyRequest, nsIPrincipal* aLoadingPrincipal, int32_t aCORSMode); bool ValidateRequestWithNewChannel(imgRequest* request, nsIURI* aURI, nsIURI* aInitialDocumentURI, nsIURI* aReferrerURI, ReferrerPolicy aReferrerPolicy, nsILoadGroup* aLoadGroup, imgINotificationObserver* aObserver, nsISupports* aCX, nsLoadFlags aLoadFlags, nsContentPolicyType aContentPolicyType, imgRequestProxy** aProxyRequest, nsIPrincipal* aLoadingPrincipal, int32_t aCORSMode); nsresult CreateNewProxyForRequest(imgRequest* aRequest, nsILoadGroup* aLoadGroup, imgINotificationObserver* aObserver, nsLoadFlags aLoadFlags, imgRequestProxy** _retval); void ReadAcceptHeaderPref(); nsresult EvictEntries(imgCacheTable& aCacheToClear); nsresult EvictEntries(imgCacheQueue& aQueueToClear); imgCacheTable& GetCache(bool aForChrome); imgCacheTable& GetCache(const ImageCacheKey& aKey); imgCacheQueue& GetCacheQueue(bool aForChrome); imgCacheQueue& GetCacheQueue(const ImageCacheKey& aKey); void CacheEntriesChanged(bool aForChrome, int32_t aSizeDiff = 0); void CheckCacheLimits(imgCacheTable& cache, imgCacheQueue& queue); private: // data friend class imgCacheEntry; friend class imgMemoryReporter; imgCacheTable mCache; imgCacheQueue mCacheQueue; imgCacheTable mChromeCache; imgCacheQueue mChromeCacheQueue; // 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; // 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; nsCString mAcceptHeader; 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 nsIStreamListener , public nsIThreadRetargetableStreamListener { public: explicit ProxyListener(nsIStreamListener* dest); /* additional members */ NS_DECL_THREADSAFE_ISUPPORTS NS_DECL_NSISTREAMLISTENER NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER NS_DECL_NSIREQUESTOBSERVER private: 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 { public: nsProgressNotificationProxy(nsIChannel* channel, imgIRequest* proxy) : mImageRequest(proxy) { channel->GetNotificationCallbacks(getter_AddRefs(mOriginalCallbacks)); } NS_DECL_ISUPPORTS NS_DECL_NSIPROGRESSEVENTSINK NS_DECL_NSICHANNELEVENTSINK NS_DECL_NSIINTERFACEREQUESTOR private: ~nsProgressNotificationProxy() { } nsCOMPtr<nsIInterfaceRequestor> mOriginalCallbacks; nsCOMPtr<nsIRequest> mImageRequest; }; /** * validate checker */ #include "nsCOMArray.h" class imgCacheValidator : public nsIStreamListener, public nsIThreadRetargetableStreamListener, public nsIChannelEventSink, public nsIInterfaceRequestor, public nsIAsyncVerifyRedirectCallback { public: imgCacheValidator(nsProgressNotificationProxy* progress, imgLoader* loader, imgRequest* aRequest, nsISupports* aContext, bool forcePrincipalCheckForCacheEntry); void AddProxy(imgRequestProxy* aProxy); NS_DECL_ISUPPORTS NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER NS_DECL_NSISTREAMLISTENER NS_DECL_NSIREQUESTOBSERVER NS_DECL_NSICHANNELEVENTSINK NS_DECL_NSIINTERFACEREQUESTOR NS_DECL_NSIASYNCVERIFYREDIRECTCALLBACK private: virtual ~imgCacheValidator(); nsCOMPtr<nsIStreamListener> mDestListener; RefPtr<nsProgressNotificationProxy> mProgressProxy; nsCOMPtr<nsIAsyncVerifyRedirectCallback> mRedirectCallback; nsCOMPtr<nsIChannel> mRedirectChannel; RefPtr<imgRequest> mRequest; nsCOMArray<imgIRequest> mProxies; RefPtr<imgRequest> mNewRequest; RefPtr<imgCacheEntry> mNewEntry; nsCOMPtr<nsISupports> mContext; imgLoader* mImgLoader; bool mHadInsecureRedirect; }; #endif // mozilla_image_imgLoader_h