gecko-dev/image/imgLoader.h

575 lines
18 KiB
C++

/* -*- 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