mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-29 07:42:04 +00:00
a230c70963
An imgRequestProxy may defer notifications when it needs to block on an imgCacheValidator. It may also be cancelled before the validator has completed its operation, but before this change, we did not remove the request from the set of proxies, imgCacheValidator::mProxies. When the deferral was completed, it would assert to ensure each proxy was still expecting a deferral before issuing the notifications. Cancelling a request can actually reset that state, which means we fail the assert. Failing the assert is actually harmless; in release we suffer no negative consequences as a result of this sequence of events. Now we just remove the proxy from the validator set to avoid asserting.
590 lines
18 KiB
C++
590 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");
|
|
NS_ASSERT_OWNINGTHREAD(imgCacheEntry);
|
|
++mRefCnt;
|
|
NS_LOG_ADDREF(this, mRefCnt, "imgCacheEntry", sizeof(*this));
|
|
return mRefCnt;
|
|
}
|
|
|
|
nsrefcnt Release()
|
|
{
|
|
NS_PRECONDITION(0 != mRefCnt, "dup release");
|
|
NS_ASSERT_OWNINGTHREAD(imgCacheEntry);
|
|
--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;
|
|
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;
|
|
|
|
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,
|
|
uint64_t aRequestContextID,
|
|
nsILoadGroup* aLoadGroup,
|
|
imgINotificationObserver* aObserver,
|
|
nsINode* aContext,
|
|
nsIDocument* aLoadingDocument,
|
|
nsLoadFlags aLoadFlags,
|
|
nsISupports* aCacheKey,
|
|
nsContentPolicyType aContentPolicyType,
|
|
const nsAString& initiatorType,
|
|
bool aUseUrgentStartForChannel,
|
|
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);
|
|
|
|
// 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();
|
|
|
|
// 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,
|
|
nsIDocument* aLoadingDocument,
|
|
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,
|
|
nsIDocument* aLoadingDocument,
|
|
nsLoadFlags aLoadFlags,
|
|
nsContentPolicyType aContentPolicyType,
|
|
imgRequestProxy** aProxyRequest,
|
|
nsIPrincipal* aLoadingPrincipal,
|
|
int32_t aCORSMode);
|
|
|
|
nsresult CreateNewProxyForRequest(imgRequest* aRequest,
|
|
nsILoadGroup* aLoadGroup,
|
|
nsIDocument* aLoadingDocument,
|
|
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);
|
|
void RemoveProxy(imgRequestProxy* aProxy);
|
|
|
|
NS_DECL_THREADSAFE_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
|