image/imgLoader.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  *
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_image_imgLoader_h
   8 #define mozilla_image_imgLoader_h
   9
  10 #include "mozilla/Attributes.h"
  11 #include "mozilla/CORSMode.h"
  12 #include "mozilla/Mutex.h"
  13 #include "mozilla/UniquePtr.h"
  14
  15 #include "imgILoader.h"
  16 #include "imgICache.h"
  17 #include "nsWeakReference.h"
  18 #include "nsIContentSniffer.h"
  19 #include "nsRefPtrHashtable.h"
  20 #include "nsTHashSet.h"
  21 #include "nsExpirationTracker.h"
  22 #include "ImageCacheKey.h"
  23 #include "imgRequest.h"
  24 #include "nsIProgressEventSink.h"
  25 #include "nsIChannel.h"
  26 #include "nsIThreadRetargetableStreamListener.h"
  27 #include "imgIRequest.h"
  28
  29 class imgLoader;
  30 class imgRequestProxy;
  31 class imgINotificationObserver;
  32 class nsILoadGroup;
  33 class imgCacheExpirationTracker;
  34 class imgMemoryReporter;
  35
  36 namespace mozilla {
  37 namespace dom {
  38 class Document;
  39 }
  40 }  // namespace mozilla
  41
  42 class imgCacheEntry {
  43  public:
  44   imgCacheEntry(imgLoader* loader, imgRequest* request,
  45                 bool aForcePrincipalCheck);
  46   ~imgCacheEntry();
  47
  48   nsrefcnt AddRef() {
  49     MOZ_ASSERT(int32_t(mRefCnt) >= 0, "illegal refcnt");
  50     NS_ASSERT_OWNINGTHREAD(imgCacheEntry);
  51     ++mRefCnt;
  52     NS_LOG_ADDREF(this, mRefCnt, "imgCacheEntry", sizeof(*this));
  53     return mRefCnt;
  54   }
  55
  56   nsrefcnt Release() {
  57     MOZ_ASSERT(0 != mRefCnt, "dup release");
  58     NS_ASSERT_OWNINGTHREAD(imgCacheEntry);
  59     --mRefCnt;
  60     NS_LOG_RELEASE(this, mRefCnt, "imgCacheEntry");
  61     if (mRefCnt == 0) {
  62       mRefCnt = 1; /* stabilize */
  63       delete this;
  64       return 0;
  65     }
  66     return mRefCnt;
  67   }
  68
  69   uint32_t GetDataSize() const { return mDataSize; }
  70   void SetDataSize(uint32_t aDataSize) {
  71     int32_t oldsize = mDataSize;
  72     mDataSize = aDataSize;
  73     UpdateCache(mDataSize - oldsize);
  74   }
  75
  76   int32_t GetTouchedTime() const { return mTouchedTime; }
  77   void SetTouchedTime(int32_t time) {
  78     mTouchedTime = time;
  79     Touch(/* updateTime = */ false);
  80   }
  81
  82   uint32_t GetLoadTime() const { return mLoadTime; }
  83
  84   void UpdateLoadTime();
  85
  86   uint32_t GetExpiryTime() const { return mExpiryTime; }
  87   void SetExpiryTime(uint32_t aExpiryTime) {
  88     mExpiryTime = aExpiryTime;
  89     Touch();
  90   }
  91
  92   bool GetMustValidate() const { return mMustValidate; }
  93   void SetMustValidate(bool aValidate) {
  94     mMustValidate = aValidate;
  95     Touch();
  96   }
  97
  98   already_AddRefed<imgRequest> GetRequest() const {
  99     RefPtr<imgRequest> req = mRequest;
 100     return req.forget();
 101   }
 102
 103   bool Evicted() const { return mEvicted; }
 104
 105   nsExpirationState* GetExpirationState() { return &mExpirationState; }
 106
 107   bool HasNoProxies() const { return mHasNoProxies; }
 108
 109   bool ForcePrincipalCheck() const { return mForcePrincipalCheck; }
 110
 111   bool HasNotified() const { return mHasNotified; }
 112   void SetHasNotified() {
 113     MOZ_ASSERT(!mHasNotified);
 114     mHasNotified = true;
 115   }
 116
 117   imgLoader* Loader() const { return mLoader; }
 118
 119  private:  // methods
 120   friend class imgLoader;
 121   friend class imgCacheQueue;
 122   void Touch(bool updateTime = true);
 123   void UpdateCache(int32_t diff = 0);
 124   void SetEvicted(bool evict) { mEvicted = evict; }
 125   void SetHasNoProxies(bool hasNoProxies);
 126
 127   // Private, unimplemented copy constructor.
 128   imgCacheEntry(const imgCacheEntry&);
 129
 130  private:  // data
 131   nsAutoRefCnt mRefCnt;
 132   NS_DECL_OWNINGTHREAD
 133
 134   imgLoader* mLoader;
 135   RefPtr<imgRequest> mRequest;
 136   uint32_t mDataSize;
 137   int32_t mTouchedTime;
 138   uint32_t mLoadTime;
 139   uint32_t mExpiryTime;
 140   nsExpirationState mExpirationState;
 141   bool mMustValidate : 1;
 142   bool mEvicted : 1;
 143   bool mHasNoProxies : 1;
 144   bool mForcePrincipalCheck : 1;
 145   bool mHasNotified : 1;
 146 };
 147
 148 #include <vector>
 149
 150 #define NS_IMGLOADER_CID                             \
 151   { /* c1354898-e3fe-4602-88a7-c4520c21cb4e */       \
 152     0xc1354898, 0xe3fe, 0x4602, {                    \
 153       0x88, 0xa7, 0xc4, 0x52, 0x0c, 0x21, 0xcb, 0x4e \
 154     }                                                \
 155   }
 156
 157 class imgCacheQueue {
 158  public:
 159   imgCacheQueue();
 160   void Remove(imgCacheEntry*);
 161   void Push(imgCacheEntry*);
 162   void MarkDirty();
 163   bool IsDirty();
 164   already_AddRefed<imgCacheEntry> Pop();
 165   void Refresh();
 166   uint32_t GetSize() const;
 167   void UpdateSize(int32_t diff);
 168   uint32_t GetNumElements() const;
 169   bool Contains(imgCacheEntry* aEntry) const;
 170   typedef nsTArray<RefPtr<imgCacheEntry>> queueContainer;
 171   typedef queueContainer::iterator iterator;
 172   typedef queueContainer::const_iterator const_iterator;
 173
 174   iterator begin();
 175   const_iterator begin() const;
 176   iterator end();
 177   const_iterator end() const;
 178
 179  private:
 180   queueContainer mQueue;
 181   bool mDirty;
 182   uint32_t mSize;
 183 };
 184
 185 enum class AcceptedMimeTypes : uint8_t {
 186   IMAGES,
 187   IMAGES_AND_DOCUMENTS,
 188 };
 189
 190 class imgLoader final : public imgILoader,
 191                         public nsIContentSniffer,
 192                         public imgICache,
 193                         public nsSupportsWeakReference,
 194                         public nsIObserver {
 195   virtual ~imgLoader();
 196
 197  public:
 198   using ImageCacheKey = mozilla::image::ImageCacheKey;
 199   using imgCacheTable =
 200       nsRefPtrHashtable<nsGenericHashKey<ImageCacheKey>, imgCacheEntry>;
 201   using imgSet = nsTHashSet<imgRequest*>;
 202   using Mutex = mozilla::Mutex;
 203
 204   NS_DECL_ISUPPORTS
 205   NS_DECL_IMGILOADER
 206   NS_DECL_NSICONTENTSNIFFER
 207   NS_DECL_IMGICACHE
 208   NS_DECL_NSIOBSERVER
 209
 210   /**
 211    * Get the normal image loader instance that is used by gecko code, creating
 212    * it if necessary.
 213    */
 214   static imgLoader* NormalLoader();
 215
 216   /**
 217    * Get the Private Browsing image loader instance that is used by gecko code,
 218    * creating it if necessary.
 219    */
 220   static imgLoader* PrivateBrowsingLoader();
 221
 222   /**
 223    * Gecko code should use NormalLoader() or PrivateBrowsingLoader() to get the
 224    * appropriate image loader.
 225    *
 226    * This constructor is public because the XPCOM module code that creates
 227    * instances of "@mozilla.org/image/loader;1" / "@mozilla.org/image/cache;1"
 228    * for nsIComponentManager.createInstance()/nsIServiceManager.getService()
 229    * calls (now only made by add-ons) needs access to it.
 230    *
 231    * XXX We would like to get rid of the nsIServiceManager.getService (and
 232    * nsIComponentManager.createInstance) method of creating imgLoader objects,
 233    * but there are add-ons that are still using it.  These add-ons don't
 234    * actually do anything useful with the loaders that they create since nobody
 235    * who creates an imgLoader using this method actually QIs to imgILoader and
 236    * loads images.  They all just QI to imgICache and either call clearCache()
 237    * or findEntryProperties().  Since they're doing this on an imgLoader that
 238    * has never loaded images, these calls are useless.  It seems likely that
 239    * the code that is doing this is just legacy code left over from a time when
 240    * there was only one imgLoader instance for the entire process.  (Nowadays
 241    * the correct method to get an imgILoader/imgICache is to call
 242    * imgITools::getImgCacheForDocument/imgITools::getImgLoaderForDocument.)
 243    * All the same, even though what these add-ons are doing is a no-op,
 244    * removing the nsIServiceManager.getService method of creating/getting an
 245    * imgLoader objects would cause an exception in these add-ons that could
 246    * break things.
 247    */
 248   imgLoader();
 249   nsresult Init();
 250
 251   bool IsImageAvailable(nsIURI*, nsIPrincipal* aTriggeringPrincipal,
 252                         mozilla::CORSMode, mozilla::dom::Document*);
 253
 254   [[nodiscard]] nsresult LoadImage(
 255       nsIURI* aURI, nsIURI* aInitialDocumentURI, nsIReferrerInfo* aReferrerInfo,
 256       nsIPrincipal* aLoadingPrincipal, uint64_t aRequestContextID,
 257       nsILoadGroup* aLoadGroup, imgINotificationObserver* aObserver,
 258       nsINode* aContext, mozilla::dom::Document* aLoadingDocument,
 259       nsLoadFlags aLoadFlags, nsISupports* aCacheKey,
 260       nsContentPolicyType aContentPolicyType, const nsAString& initiatorType,
 261       bool aUseUrgentStartForChannel, bool aLinkPreload,
 262       uint64_t aEarlyHintPreloaderId, imgRequestProxy** _retval);
 263
 264   [[nodiscard]] nsresult LoadImageWithChannel(
 265       nsIChannel* channel, imgINotificationObserver* aObserver,
 266       mozilla::dom::Document* aLoadingDocument, nsIStreamListener** listener,
 267       imgRequestProxy** _retval);
 268
 269   static nsresult GetMimeTypeFromContent(const char* aContents,
 270                                          uint32_t aLength,
 271                                          nsACString& aContentType);
 272
 273   /**
 274    * Returns true if the given mime type may be interpreted as an image.
 275    *
 276    * Some MIME types may be interpreted as both images and documents. (At the
 277    * moment only "image/svg+xml" falls into this category, but there may be more
 278    * in the future.) Callers which want this function to return true for such
 279    * MIME types should pass AcceptedMimeTypes::IMAGES_AND_DOCUMENTS for
 280    * @aAccept.
 281    *
 282    * @param aMimeType The MIME type to evaluate.
 283    * @param aAcceptedMimeTypes Which kinds of MIME types to treat as images.
 284    */
 285   static bool SupportImageWithMimeType(
 286       const nsACString&, AcceptedMimeTypes aAccept = AcceptedMimeTypes::IMAGES);
 287
 288   static void GlobalInit();  // for use by the factory
 289   static void Shutdown();    // for use by the factory
 290   static void ShutdownMemoryReporter();
 291
 292   nsresult ClearChromeImageCache();
 293   nsresult ClearImageCache();
 294   void MinimizeCaches();
 295
 296   nsresult InitCache();
 297
 298   bool RemoveFromCache(const ImageCacheKey& aKey);
 299
 300   // Enumeration describing if a given entry is in the cache queue or not.
 301   // There are some cases we know the entry is definitely not in the queue.
 302   enum class QueueState { MaybeExists, AlreadyRemoved };
 303
 304   bool RemoveFromCache(imgCacheEntry* entry,
 305                        QueueState aQueueState = QueueState::MaybeExists);
 306
 307   bool PutIntoCache(const ImageCacheKey& aKey, imgCacheEntry* aEntry);
 308
 309   void AddToUncachedImages(imgRequest* aRequest);
 310   void RemoveFromUncachedImages(imgRequest* aRequest);
 311
 312   // Returns true if we should prefer evicting cache entry |two| over cache
 313   // entry |one|.
 314   // This mixes units in the worst way, but provides reasonable results.
 315   inline static bool CompareCacheEntries(const RefPtr<imgCacheEntry>& one,
 316                                          const RefPtr<imgCacheEntry>& two) {
 317     if (!one) {
 318       return false;
 319     }
 320     if (!two) {
 321       return true;
 322     }
 323
 324     const double sizeweight = 1.0 - sCacheTimeWeight;
 325
 326     // We want large, old images to be evicted first (depending on their
 327     // relative weights). Since a larger time is actually newer, we subtract
 328     // time's weight, so an older image has a larger weight.
 329     double oneweight = double(one->GetDataSize()) * sizeweight -
 330                        double(one->GetTouchedTime()) * sCacheTimeWeight;
 331     double twoweight = double(two->GetDataSize()) * sizeweight -
 332                        double(two->GetTouchedTime()) * sCacheTimeWeight;
 333
 334     return oneweight < twoweight;
 335   }
 336
 337   void VerifyCacheSizes();
 338
 339   nsresult RemoveEntriesInternal(nsIPrincipal* aPrincipal,
 340                                  const nsACString* aBaseDomain);
 341
 342   // The image loader maintains a hash table of all imgCacheEntries. However,
 343   // only some of them will be evicted from the cache: those who have no
 344   // imgRequestProxies watching their imgRequests.
 345   //
 346   // Once an imgRequest has no imgRequestProxies, it should notify us by
 347   // calling HasNoObservers(), and null out its cache entry pointer.
 348   //
 349   // Upon having a proxy start observing again, it should notify us by calling
 350   // HasObservers(). The request's cache entry will be re-set before this
 351   // happens, by calling imgRequest::SetCacheEntry() when an entry with no
 352   // observers is re-requested.
 353   bool SetHasNoProxies(imgRequest* aRequest, imgCacheEntry* aEntry);
 354   bool SetHasProxies(imgRequest* aRequest);
 355
 356  private:  // methods
 357   static already_AddRefed<imgLoader> CreateImageLoader();
 358
 359   bool ValidateEntry(imgCacheEntry* aEntry, nsIURI* aURI,
 360                      nsIURI* aInitialDocumentURI,
 361                      nsIReferrerInfo* aReferrerInfo, nsILoadGroup* aLoadGroup,
 362                      imgINotificationObserver* aObserver,
 363                      mozilla::dom::Document* aLoadingDocument,
 364                      nsLoadFlags aLoadFlags,
 365                      nsContentPolicyType aLoadPolicyType,
 366                      bool aCanMakeNewChannel, bool* aNewChannelCreated,
 367                      imgRequestProxy** aProxyRequest,
 368                      nsIPrincipal* aTriggeringPrincipal, mozilla::CORSMode,
 369                      bool aLinkPreload, uint64_t aEarlyHintPreloaderId);
 370
 371   bool ValidateRequestWithNewChannel(
 372       imgRequest* request, nsIURI* aURI, nsIURI* aInitialDocumentURI,
 373       nsIReferrerInfo* aReferrerInfo, nsILoadGroup* aLoadGroup,
 374       imgINotificationObserver* aObserver,
 375       mozilla::dom::Document* aLoadingDocument, uint64_t aInnerWindowId,
 376       nsLoadFlags aLoadFlags, nsContentPolicyType aContentPolicyType,
 377       imgRequestProxy** aProxyRequest, nsIPrincipal* aLoadingPrincipal,
 378       mozilla::CORSMode, bool aLinkPreload, uint64_t aEarlyHintPreloaderId,
 379       bool* aNewChannelCreated);
 380
 381   void NotifyObserversForCachedImage(imgCacheEntry* aEntry, imgRequest* request,
 382                                      nsIURI* aURI,
 383                                      nsIReferrerInfo* aReferrerInfo,
 384                                      mozilla::dom::Document* aLoadingDocument,
 385                                      nsIPrincipal* aLoadingPrincipal,
 386                                      mozilla::CORSMode,
 387                                      uint64_t aEarlyHintPreloaderId);
 388   // aURI may be different from imgRequest's URI in the case of blob URIs, as we
 389   // can share requests with different URIs.
 390   nsresult CreateNewProxyForRequest(imgRequest* aRequest, nsIURI* aURI,
 391                                     nsILoadGroup* aLoadGroup,
 392                                     mozilla::dom::Document* aLoadingDocument,
 393                                     imgINotificationObserver* aObserver,
 394                                     nsLoadFlags aLoadFlags,
 395                                     imgRequestProxy** _retval);
 396
 397   nsresult EvictEntries(imgCacheTable& aCacheToClear);
 398   nsresult EvictEntries(imgCacheQueue& aQueueToClear);
 399
 400   imgCacheTable& GetCache(bool aForChrome);
 401   imgCacheTable& GetCache(const ImageCacheKey& aKey);
 402   imgCacheQueue& GetCacheQueue(bool aForChrome);
 403   imgCacheQueue& GetCacheQueue(const ImageCacheKey& aKey);
 404   void CacheEntriesChanged(bool aForChrome, int32_t aSizeDiff = 0);
 405   void CheckCacheLimits(imgCacheTable& cache, imgCacheQueue& queue);
 406
 407  private:  // data
 408   friend class imgCacheEntry;
 409   friend class imgMemoryReporter;
 410
 411   imgCacheTable mCache;
 412   imgCacheQueue mCacheQueue;
 413
 414   imgCacheTable mChromeCache;
 415   imgCacheQueue mChromeCacheQueue;
 416
 417   // Hash set of every imgRequest for this loader that isn't in mCache or
 418   // mChromeCache. The union over all imgLoader's of mCache, mChromeCache, and
 419   // mUncachedImages should be every imgRequest that is alive. These are weak
 420   // pointers so we rely on the imgRequest destructor to remove itself.
 421   imgSet mUncachedImages MOZ_GUARDED_BY(mUncachedImagesMutex);
 422   // The imgRequest can have refs to them held on non-main thread, so we need
 423   // a mutex because we modify the uncached images set from the imgRequest
 424   // destructor.
 425   Mutex mUncachedImagesMutex;
 426
 427   static double sCacheTimeWeight;
 428   static uint32_t sCacheMaxSize;
 429   static imgMemoryReporter* sMemReporter;
 430
 431   mozilla::UniquePtr<imgCacheExpirationTracker> mCacheTracker;
 432   bool mRespectPrivacy;
 433 };
 434
 435 /**
 436  * proxy stream listener class used to handle multipart/x-mixed-replace
 437  */
 438
 439 #include "nsCOMPtr.h"
 440 #include "nsIStreamListener.h"
 441 #include "nsIThreadRetargetableStreamListener.h"
 442
 443 class ProxyListener : public nsIStreamListener,
 444                       public nsIThreadRetargetableStreamListener {
 445  public:
 446   explicit ProxyListener(nsIStreamListener* dest);
 447
 448   /* additional members */
 449   NS_DECL_THREADSAFE_ISUPPORTS
 450   NS_DECL_NSISTREAMLISTENER
 451   NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
 452   NS_DECL_NSIREQUESTOBSERVER
 453
 454  private:
 455   virtual ~ProxyListener();
 456
 457   nsCOMPtr<nsIStreamListener> mDestListener;
 458 };
 459
 460 /**
 461  * A class that implements nsIProgressEventSink and forwards all calls to it to
 462  * the original notification callbacks of the channel. Also implements
 463  * nsIInterfaceRequestor and gives out itself for nsIProgressEventSink calls,
 464  * and forwards everything else to the channel's notification callbacks.
 465  */
 466 class nsProgressNotificationProxy final : public nsIProgressEventSink,
 467                                           public nsIChannelEventSink,
 468                                           public nsIInterfaceRequestor {
 469  public:
 470   nsProgressNotificationProxy(nsIChannel* channel, imgIRequest* proxy)
 471       : mImageRequest(proxy) {
 472     channel->GetNotificationCallbacks(getter_AddRefs(mOriginalCallbacks));
 473   }
 474
 475   NS_DECL_ISUPPORTS
 476   NS_DECL_NSIPROGRESSEVENTSINK
 477   NS_DECL_NSICHANNELEVENTSINK
 478   NS_DECL_NSIINTERFACEREQUESTOR
 479  private:
 480   ~nsProgressNotificationProxy() = default;
 481
 482   nsCOMPtr<nsIInterfaceRequestor> mOriginalCallbacks;
 483   nsCOMPtr<nsIRequest> mImageRequest;
 484 };
 485
 486 /**
 487  * validate checker
 488  */
 489
 490 #include "nsCOMArray.h"
 491
 492 class imgCacheValidator : public nsIStreamListener,
 493                           public nsIThreadRetargetableStreamListener,
 494                           public nsIChannelEventSink,
 495                           public nsIInterfaceRequestor,
 496                           public nsIAsyncVerifyRedirectCallback {
 497  public:
 498   imgCacheValidator(nsProgressNotificationProxy* progress, imgLoader* loader,
 499                     imgRequest* aRequest, mozilla::dom::Document* aDocument,
 500                     uint64_t aInnerWindowId,
 501                     bool forcePrincipalCheckForCacheEntry);
 502
 503   void AddProxy(imgRequestProxy* aProxy);
 504   void RemoveProxy(imgRequestProxy* aProxy);
 505
 506   NS_DECL_THREADSAFE_ISUPPORTS
 507   NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
 508   NS_DECL_NSISTREAMLISTENER
 509   NS_DECL_NSIREQUESTOBSERVER
 510   NS_DECL_NSICHANNELEVENTSINK
 511   NS_DECL_NSIINTERFACEREQUESTOR
 512   NS_DECL_NSIASYNCVERIFYREDIRECTCALLBACK
 513
 514  private:
 515   void UpdateProxies(bool aCancelRequest, bool aSyncNotify);
 516   virtual ~imgCacheValidator();
 517
 518   nsCOMPtr<nsIStreamListener> mDestListener;
 519   RefPtr<nsProgressNotificationProxy> mProgressProxy;
 520   nsCOMPtr<nsIAsyncVerifyRedirectCallback> mRedirectCallback;
 521   nsCOMPtr<nsIChannel> mRedirectChannel;
 522
 523   RefPtr<imgRequest> mRequest;
 524   AutoTArray<RefPtr<imgRequestProxy>, 4> mProxies;
 525
 526   RefPtr<imgRequest> mNewRequest;
 527   RefPtr<imgCacheEntry> mNewEntry;
 528
 529   RefPtr<mozilla::dom::Document> mDocument;
 530   uint64_t mInnerWindowId;
 531
 532   imgLoader* mImgLoader;
 533
 534   bool mHadInsecureRedirect;
 535 };
 536
 537 #endif  // mozilla_image_imgLoader_h