diff options
Diffstat (limited to 'image/imgLoader.h')
| -rw-r--r-- | image/imgLoader.h | 574 |
1 files changed, 574 insertions, 0 deletions
diff --git a/image/imgLoader.h b/image/imgLoader.h new file mode 100644 index 000000000..8e818a290 --- /dev/null +++ b/image/imgLoader.h @@ -0,0 +1,574 @@ +/* -*- 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 |