image/imgRequestProxy.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_imgRequestProxy_h
   8 #define mozilla_image_imgRequestProxy_h
   9
  10 #include "imgIRequest.h"
  11 #include "nsISecurityInfoProvider.h"
  12
  13 #include "nsILoadGroup.h"
  14 #include "nsISupportsPriority.h"
  15 #include "nsITimedChannel.h"
  16 #include "nsCOMPtr.h"
  17 #include "nsThreadUtils.h"
  18 #include "mozilla/TimeStamp.h"
  19 #include "mozilla/UniquePtr.h"
  20 #include "mozilla/gfx/Rect.h"
  21
  22 #include "imgRequest.h"
  23 #include "IProgressObserver.h"
  24
  25 #define NS_IMGREQUESTPROXY_CID \
  26 { /* 20557898-1dd2-11b2-8f65-9c462ee2bc95 */         \
  27      0x20557898,                                     \
  28      0x1dd2,                                         \
  29      0x11b2,                                         \
  30     {0x8f, 0x65, 0x9c, 0x46, 0x2e, 0xe2, 0xbc, 0x95} \
  31 }
  32
  33 class imgCacheValidator;
  34 class imgINotificationObserver;
  35 class imgStatusNotifyRunnable;
  36 class ProxyBehaviour;
  37
  38 namespace mozilla {
  39 namespace dom {
  40 class TabGroup;
  41 }
  42
  43 namespace image {
  44 class Image;
  45 class ImageURL;
  46 class ProgressTracker;
  47 } // namespace image
  48 } // namespace mozilla
  49
  50 class imgRequestProxy : public imgIRequest,
  51                         public mozilla::image::IProgressObserver,
  52                         public nsISupportsPriority,
  53                         public nsISecurityInfoProvider,
  54                         public nsITimedChannel
  55 {
  56 protected:
  57   virtual ~imgRequestProxy();
  58
  59 public:
  60   typedef mozilla::image::Image Image;
  61   typedef mozilla::image::ImageURL ImageURL;
  62   typedef mozilla::image::ProgressTracker ProgressTracker;
  63
  64   MOZ_DECLARE_REFCOUNTED_TYPENAME(imgRequestProxy)
  65   NS_DECL_ISUPPORTS
  66   NS_DECL_IMGIREQUEST
  67   NS_DECL_NSIREQUEST
  68   NS_DECL_NSISUPPORTSPRIORITY
  69   NS_DECL_NSISECURITYINFOPROVIDER
  70   // nsITimedChannel declared below
  71
  72   imgRequestProxy();
  73
  74   // Callers to Init or ChangeOwner are required to call NotifyListener after
  75   // (although not immediately after) doing so.
  76   nsresult Init(imgRequest* aOwner,
  77                 nsILoadGroup* aLoadGroup,
  78                 nsIDocument* aLoadingDocument,
  79                 ImageURL* aURI,
  80                 imgINotificationObserver* aObserver);
  81
  82   nsresult ChangeOwner(imgRequest* aNewOwner); // this will change mOwner.
  83                                                // Do not call this if the
  84                                                // previous owner has already
  85                                                // sent notifications out!
  86
  87   // Add the request to the load group, if any. This should only be called once
  88   // during initialization.
  89   void AddToLoadGroup();
  90
  91   inline bool HasObserver() const {
  92     return mListener != nullptr;
  93   }
  94
  95   // Asynchronously notify this proxy's listener of the current state of the
  96   // image, and, if we have an imgRequest mOwner, any status changes that
  97   // happen between the time this function is called and the time the
  98   // notification is scheduled.
  99   void NotifyListener();
 100
 101   // Synchronously notify this proxy's listener of the current state of the
 102   // image. Only use this function if you are currently servicing an
 103   // asynchronously-called function.
 104   void SyncNotifyListener();
 105
 106   // imgINotificationObserver methods:
 107   virtual void Notify(int32_t aType,
 108                       const mozilla::gfx::IntRect* aRect = nullptr) override;
 109   virtual void OnLoadComplete(bool aLastPart) override;
 110
 111   // Other, internal-only methods:
 112   virtual void SetHasImage() override;
 113
 114   // Whether we want notifications from ProgressTracker to be deferred until
 115   // an event it has scheduled has been fired and/or validation is complete.
 116   virtual bool NotificationsDeferred() const override
 117   {
 118     return IsValidating() || mPendingNotify;
 119   }
 120   virtual void MarkPendingNotify() override
 121   {
 122     mPendingNotify = true;
 123   }
 124   virtual void ClearPendingNotify() override
 125   {
 126     mPendingNotify = false;
 127   }
 128   bool IsValidating() const
 129   {
 130     return mValidating;
 131   }
 132   void MarkValidating();
 133   void ClearValidating();
 134
 135   bool IsOnEventTarget() const;
 136   already_AddRefed<nsIEventTarget> GetEventTarget() const override;
 137
 138   // Removes all animation consumers that were created with
 139   // IncrementAnimationConsumers. This is necessary since we need
 140   // to do it before the proxy itself is destroyed. See
 141   // imgRequest::RemoveProxy
 142   void ClearAnimationConsumers();
 143
 144   nsresult SyncClone(imgINotificationObserver* aObserver,
 145                      nsIDocument* aLoadingDocument,
 146                      imgRequestProxy** aClone);
 147   nsresult Clone(imgINotificationObserver* aObserver,
 148                  nsIDocument* aLoadingDocument,
 149                  imgRequestProxy** aClone);
 150   nsresult GetStaticRequest(nsIDocument* aLoadingDocument,
 151                             imgRequestProxy** aReturn);
 152
 153   nsresult GetURI(ImageURL** aURI);
 154
 155 protected:
 156   friend class mozilla::image::ProgressTracker;
 157   friend class imgStatusNotifyRunnable;
 158
 159   class imgCancelRunnable;
 160   friend class imgCancelRunnable;
 161
 162   class imgCancelRunnable : public mozilla::Runnable
 163   {
 164     public:
 165       imgCancelRunnable(imgRequestProxy* owner, nsresult status)
 166         : Runnable("imgCancelRunnable"), mOwner(owner), mStatus(status)
 167       { }
 168
 169       NS_IMETHOD Run() override {
 170         mOwner->DoCancel(mStatus);
 171         return NS_OK;
 172       }
 173
 174     private:
 175       RefPtr<imgRequestProxy> mOwner;
 176       nsresult mStatus;
 177   };
 178
 179   /* Remove from and forget the load group. */
 180   void RemoveFromLoadGroup();
 181
 182   /* Remove from the load group and readd as a background request. */
 183   void MoveToBackgroundInLoadGroup();
 184
 185   /* Finish up canceling ourselves */
 186   void DoCancel(nsresult status);
 187
 188   /* Do the proper refcount management to null out mListener */
 189   void NullOutListener();
 190
 191   // Return the ProgressTracker associated with mOwner and/or mImage. It may
 192   // live either on mOwner or mImage, depending on whether
 193   //   (a) we have an mOwner at all
 194   //   (b) whether mOwner has instantiated its image yet
 195   already_AddRefed<ProgressTracker> GetProgressTracker() const;
 196
 197   nsITimedChannel* TimedChannel()
 198   {
 199     if (!GetOwner()) {
 200       return nullptr;
 201     }
 202     return GetOwner()->GetTimedChannel();
 203   }
 204
 205   already_AddRefed<Image> GetImage() const;
 206   bool HasImage() const;
 207   imgRequest* GetOwner() const;
 208   imgCacheValidator* GetValidator() const;
 209
 210   nsresult PerformClone(imgINotificationObserver* aObserver,
 211                         nsIDocument* aLoadingDocument,
 212                         bool aSyncNotify,
 213                         imgRequestProxy** aClone);
 214
 215   virtual imgRequestProxy* NewClonedProxy();
 216
 217 public:
 218   NS_FORWARD_SAFE_NSITIMEDCHANNEL(TimedChannel())
 219
 220 protected:
 221   mozilla::UniquePtr<ProxyBehaviour> mBehaviour;
 222
 223 private:
 224   friend class imgCacheValidator;
 225
 226   void AddToOwner(nsIDocument* aLoadingDocument);
 227   void RemoveFromOwner(nsresult aStatus);
 228
 229   nsresult DispatchWithTargetIfAvailable(already_AddRefed<nsIRunnable> aEvent);
 230   void DispatchWithTarget(already_AddRefed<nsIRunnable> aEvent);
 231
 232   // The URI of our request.
 233   RefPtr<ImageURL> mURI;
 234
 235   // mListener is only promised to be a weak ref (see imgILoader.idl),
 236   // but we actually keep a strong ref to it until we've seen our
 237   // first OnStopRequest.
 238   imgINotificationObserver* MOZ_UNSAFE_REF("Observers must call Cancel() or "
 239                                            "CancelAndForgetObserver() before "
 240                                            "they are destroyed") mListener;
 241
 242   nsCOMPtr<nsILoadGroup> mLoadGroup;
 243   RefPtr<mozilla::dom::TabGroup> mTabGroup;
 244   nsCOMPtr<nsIEventTarget> mEventTarget;
 245
 246   nsLoadFlags mLoadFlags;
 247   uint32_t    mLockCount;
 248   uint32_t    mAnimationConsumers;
 249   bool mCanceled : 1;
 250   bool mIsInLoadGroup : 1;
 251   bool mForceDispatchLoadGroup : 1;
 252   bool mListenerIsStrongRef : 1;
 253   bool mDecodeRequested : 1;
 254
 255   // Whether we want to defer our notifications by the non-virtual Observer
 256   // interfaces as image loads proceed.
 257   bool mPendingNotify : 1;
 258   bool mValidating : 1;
 259   bool mHadListener : 1;
 260   bool mHadDispatch : 1;
 261 };
 262
 263 // Used for static image proxies for which no requests are available, so
 264 // certain behaviours must be overridden to compensate.
 265 class imgRequestProxyStatic : public imgRequestProxy
 266 {
 267
 268 public:
 269   imgRequestProxyStatic(Image* aImage, nsIPrincipal* aPrincipal);
 270
 271   NS_IMETHOD GetImagePrincipal(nsIPrincipal** aPrincipal) override;
 272
 273 protected:
 274   imgRequestProxy* NewClonedProxy() override;
 275
 276   // Our principal. We have to cache it, rather than accessing the underlying
 277   // request on-demand, because static proxies don't have an underlying request.
 278   nsCOMPtr<nsIPrincipal> mPrincipal;
 279 };
 280
 281 #endif // mozilla_image_imgRequestProxy_h