1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. */
7 #ifndef mozilla_image_imgRequestProxy_h
8 #define mozilla_image_imgRequestProxy_h
10 #include "imgIRequest.h"
12 #include "nsILoadGroup.h"
13 #include "nsISupportsPriority.h"
14 #include "nsITimedChannel.h"
16 #include "nsThreadUtils.h"
17 #include "mozilla/PreloaderBase.h"
18 #include "mozilla/TimeStamp.h"
19 #include "mozilla/UniquePtr.h"
20 #include "mozilla/gfx/Rect.h"
22 #include "imgRequest.h"
23 #include "IProgressObserver.h"
25 #define NS_IMGREQUESTPROXY_CID \
26 { /* 20557898-1dd2-11b2-8f65-9c462ee2bc95 */ \
27 0x20557898, 0x1dd2, 0x11b2, { \
28 0x8f, 0x65, 0x9c, 0x46, 0x2e, 0xe2, 0xbc, 0x95 \
32 class imgCacheValidator
;
33 class imgINotificationObserver
;
34 class imgStatusNotifyRunnable
;
40 class ProgressTracker
;
42 } // namespace mozilla
44 class imgRequestProxy
: public mozilla::PreloaderBase
,
46 public mozilla::image::IProgressObserver
,
47 public nsISupportsPriority
,
48 public nsITimedChannel
{
50 virtual ~imgRequestProxy();
53 typedef mozilla::dom::Document Document
;
54 typedef mozilla::image::Image Image
;
55 typedef mozilla::image::ProgressTracker ProgressTracker
;
57 NS_DECLARE_STATIC_IID_ACCESSOR(NS_IMGREQUESTPROXY_CID
)
58 MOZ_DECLARE_REFCOUNTED_TYPENAME(imgRequestProxy
)
62 NS_DECL_NSISUPPORTSPRIORITY
63 // nsITimedChannel declared below
67 // Callers to Init or ChangeOwner are required to call NotifyListener after
68 // (although not immediately after) doing so.
69 nsresult
Init(imgRequest
* aOwner
, nsILoadGroup
* aLoadGroup
,
70 Document
* aLoadingDocument
, nsIURI
* aURI
,
71 imgINotificationObserver
* aObserver
);
73 nsresult
ChangeOwner(imgRequest
* aNewOwner
); // this will change mOwner.
74 // Do not call this if the
75 // previous owner has already
76 // sent notifications out!
78 // Add the request to the load group, if any. This should only be called once
79 // during initialization.
80 void AddToLoadGroup();
82 inline bool HasObserver() const { return mListener
!= nullptr; }
84 // Asynchronously notify this proxy's listener of the current state of the
85 // image, and, if we have an imgRequest mOwner, any status changes that
86 // happen between the time this function is called and the time the
87 // notification is scheduled.
88 void NotifyListener();
90 // Synchronously notify this proxy's listener of the current state of the
91 // image. Only use this function if you are currently servicing an
92 // asynchronously-called function.
93 void SyncNotifyListener();
95 // imgINotificationObserver methods:
96 virtual void Notify(int32_t aType
,
97 const mozilla::gfx::IntRect
* aRect
= nullptr) override
;
98 virtual void OnLoadComplete(bool aLastPart
) override
;
100 // Other, internal-only methods:
101 virtual void SetHasImage() override
;
103 // Whether we want notifications from ProgressTracker to be deferred until
104 // an event it has scheduled has been fired and/or validation is complete.
105 virtual bool NotificationsDeferred() const override
{
106 return IsValidating() || mPendingNotify
;
108 virtual void MarkPendingNotify() override
{ mPendingNotify
= true; }
109 virtual void ClearPendingNotify() override
{ mPendingNotify
= false; }
110 bool IsValidating() const { return mValidating
; }
111 void MarkValidating();
112 void ClearValidating();
114 bool IsOnEventTarget() const;
115 already_AddRefed
<nsIEventTarget
> GetEventTarget() const override
;
117 // Removes all animation consumers that were created with
118 // IncrementAnimationConsumers. This is necessary since we need
119 // to do it before the proxy itself is destroyed. See
120 // imgRequest::RemoveProxy
121 void ClearAnimationConsumers();
123 nsresult
SyncClone(imgINotificationObserver
* aObserver
,
124 Document
* aLoadingDocument
, imgRequestProxy
** aClone
);
125 nsresult
Clone(imgINotificationObserver
* aObserver
,
126 Document
* aLoadingDocument
, imgRequestProxy
** aClone
);
127 nsresult
GetStaticRequest(Document
* aLoadingDocument
,
128 imgRequestProxy
** aReturn
);
130 imgRequest
* GetOwner() const;
133 // We are using the default image loader prioritization for preloads.
134 virtual void PrioritizeAsPreload() override
{}
137 friend class mozilla::image::ProgressTracker
;
138 friend class imgStatusNotifyRunnable
;
140 class imgCancelRunnable
;
141 friend class imgCancelRunnable
;
143 class imgCancelRunnable
: public mozilla::Runnable
{
145 imgCancelRunnable(imgRequestProxy
* owner
, nsresult status
)
146 : Runnable("imgCancelRunnable"), mOwner(owner
), mStatus(status
) {}
148 NS_IMETHOD
Run() override
{
149 mOwner
->DoCancel(mStatus
);
154 RefPtr
<imgRequestProxy
> mOwner
;
158 /* Remove from and forget the load group. */
159 void RemoveFromLoadGroup();
161 /* Remove from the load group and re-add as a background request. */
162 void MoveToBackgroundInLoadGroup();
164 /* Finish up canceling ourselves */
165 void DoCancel(nsresult status
);
167 /* Do the proper refcount management to null out mListener */
168 void NullOutListener();
170 // Return the ProgressTracker associated with mOwner and/or mImage. It may
171 // live either on mOwner or mImage, depending on whether
172 // (a) we have an mOwner at all
173 // (b) whether mOwner has instantiated its image yet
174 already_AddRefed
<ProgressTracker
> GetProgressTracker() const;
176 nsITimedChannel
* TimedChannel() {
180 return GetOwner()->GetTimedChannel();
183 already_AddRefed
<Image
> GetImage() const;
184 bool HasImage() const;
185 imgCacheValidator
* GetValidator() const;
187 nsresult
PerformClone(imgINotificationObserver
* aObserver
,
188 Document
* aLoadingDocument
, bool aSyncNotify
,
189 imgRequestProxy
** aClone
);
191 virtual imgRequestProxy
* NewClonedProxy();
194 NS_FORWARD_SAFE_NSITIMEDCHANNEL(TimedChannel())
197 mozilla::UniquePtr
<ProxyBehaviour
> mBehaviour
;
200 friend class imgCacheValidator
;
202 void AddToOwner(Document
* aLoadingDocument
);
203 void RemoveFromOwner(nsresult aStatus
);
205 nsresult
DispatchWithTargetIfAvailable(already_AddRefed
<nsIRunnable
> aEvent
);
206 void DispatchWithTarget(already_AddRefed
<nsIRunnable
> aEvent
);
208 // The URI of our request.
209 nsCOMPtr
<nsIURI
> mURI
;
211 // mListener is only promised to be a weak ref (see imgILoader.idl),
212 // but we actually keep a strong ref to it until we've seen our
213 // first OnStopRequest.
214 imgINotificationObserver
* MOZ_UNSAFE_REF(
215 "Observers must call Cancel() or "
216 "CancelAndForgetObserver() before "
217 "they are destroyed") mListener
;
219 nsCOMPtr
<nsILoadGroup
> mLoadGroup
;
220 nsCOMPtr
<nsIEventTarget
> mEventTarget
;
222 nsLoadFlags mLoadFlags
;
224 uint32_t mAnimationConsumers
;
226 bool mIsInLoadGroup
: 1;
227 bool mForceDispatchLoadGroup
: 1;
228 bool mListenerIsStrongRef
: 1;
229 bool mDecodeRequested
: 1;
231 // Whether we want to defer our notifications by the non-virtual Observer
232 // interfaces as image loads proceed.
233 bool mPendingNotify
: 1;
234 bool mValidating
: 1;
235 bool mHadListener
: 1;
236 bool mHadDispatch
: 1;
239 NS_DEFINE_STATIC_IID_ACCESSOR(imgRequestProxy
, NS_IMGREQUESTPROXY_CID
)
241 // Used for static image proxies for which no requests are available, so
242 // certain behaviours must be overridden to compensate.
243 class imgRequestProxyStatic
: public imgRequestProxy
{
245 imgRequestProxyStatic(Image
* aImage
, nsIPrincipal
* aPrincipal
,
246 bool hadCrossOriginRedirects
);
248 NS_IMETHOD
GetImagePrincipal(nsIPrincipal
** aPrincipal
) override
;
250 NS_IMETHOD
GetHadCrossOriginRedirects(
251 bool* aHadCrossOriginRedirects
) override
;
254 imgRequestProxy
* NewClonedProxy() override
;
256 // Our principal. We have to cache it, rather than accessing the underlying
257 // request on-demand, because static proxies don't have an underlying request.
258 nsCOMPtr
<nsIPrincipal
> mPrincipal
;
259 const bool mHadCrossOriginRedirects
;
262 #endif // mozilla_image_imgRequestProxy_h