Line data Source code
1 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 : /* This Source Code Form is subject to the terms of the Mozilla Public
3 : * License, v. 2.0. If a copy of the MPL was not distributed with this
4 : * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5 :
6 : #include "ImageWrapper.h"
7 : #include "mozilla/gfx/2D.h"
8 : #include "mozilla/RefPtr.h"
9 : #include "Orientation.h"
10 :
11 : #include "mozilla/MemoryReporting.h"
12 :
13 : namespace mozilla {
14 :
15 : using gfx::DataSourceSurface;
16 : using gfx::IntSize;
17 : using gfx::SamplingFilter;
18 : using gfx::SourceSurface;
19 : using layers::LayerManager;
20 : using layers::ImageContainer;
21 :
22 : namespace image {
23 :
24 : // Inherited methods from Image.
25 :
26 : already_AddRefed<ProgressTracker>
27 0 : ImageWrapper::GetProgressTracker()
28 : {
29 0 : return mInnerImage->GetProgressTracker();
30 : }
31 :
32 : size_t
33 0 : ImageWrapper::SizeOfSourceWithComputedFallback(MallocSizeOf aMallocSizeOf) const
34 : {
35 0 : return mInnerImage->SizeOfSourceWithComputedFallback(aMallocSizeOf);
36 : }
37 :
38 : void
39 0 : ImageWrapper::CollectSizeOfSurfaces(nsTArray<SurfaceMemoryCounter>& aCounters,
40 : MallocSizeOf aMallocSizeOf) const
41 : {
42 0 : mInnerImage->CollectSizeOfSurfaces(aCounters, aMallocSizeOf);
43 0 : }
44 :
45 : void
46 0 : ImageWrapper::IncrementAnimationConsumers()
47 : {
48 0 : MOZ_ASSERT(NS_IsMainThread(), "Main thread only to encourage serialization "
49 : "with DecrementAnimationConsumers");
50 0 : mInnerImage->IncrementAnimationConsumers();
51 0 : }
52 :
53 : void
54 0 : ImageWrapper::DecrementAnimationConsumers()
55 : {
56 0 : MOZ_ASSERT(NS_IsMainThread(), "Main thread only to encourage serialization "
57 : "with IncrementAnimationConsumers");
58 0 : mInnerImage->DecrementAnimationConsumers();
59 0 : }
60 :
61 : #ifdef DEBUG
62 : uint32_t
63 0 : ImageWrapper::GetAnimationConsumers()
64 : {
65 0 : return mInnerImage->GetAnimationConsumers();
66 : }
67 : #endif
68 :
69 : nsresult
70 0 : ImageWrapper::OnImageDataAvailable(nsIRequest* aRequest,
71 : nsISupports* aContext,
72 : nsIInputStream* aInStr,
73 : uint64_t aSourceOffset,
74 : uint32_t aCount)
75 : {
76 0 : return mInnerImage->OnImageDataAvailable(aRequest, aContext, aInStr,
77 0 : aSourceOffset, aCount);
78 : }
79 :
80 : nsresult
81 0 : ImageWrapper::OnImageDataComplete(nsIRequest* aRequest,
82 : nsISupports* aContext,
83 : nsresult aStatus,
84 : bool aLastPart)
85 : {
86 0 : return mInnerImage->OnImageDataComplete(aRequest, aContext, aStatus,
87 0 : aLastPart);
88 : }
89 :
90 : void
91 0 : ImageWrapper::OnSurfaceDiscarded(const SurfaceKey& aSurfaceKey)
92 : {
93 0 : return mInnerImage->OnSurfaceDiscarded(aSurfaceKey);
94 : }
95 :
96 : void
97 0 : ImageWrapper::SetInnerWindowID(uint64_t aInnerWindowId)
98 : {
99 0 : mInnerImage->SetInnerWindowID(aInnerWindowId);
100 0 : }
101 :
102 : uint64_t
103 0 : ImageWrapper::InnerWindowID() const
104 : {
105 0 : return mInnerImage->InnerWindowID();
106 : }
107 :
108 : bool
109 0 : ImageWrapper::HasError()
110 : {
111 0 : return mInnerImage->HasError();
112 : }
113 :
114 : void
115 0 : ImageWrapper::SetHasError()
116 : {
117 0 : mInnerImage->SetHasError();
118 0 : }
119 :
120 : ImageURL*
121 0 : ImageWrapper::GetURI()
122 : {
123 0 : return mInnerImage->GetURI();
124 : }
125 :
126 : // Methods inherited from XPCOM interfaces.
127 :
128 448 : NS_IMPL_ISUPPORTS(ImageWrapper, imgIContainer)
129 :
130 : NS_IMETHODIMP
131 0 : ImageWrapper::GetWidth(int32_t* aWidth)
132 : {
133 0 : return mInnerImage->GetWidth(aWidth);
134 : }
135 :
136 : NS_IMETHODIMP
137 0 : ImageWrapper::GetHeight(int32_t* aHeight)
138 : {
139 0 : return mInnerImage->GetHeight(aHeight);
140 : }
141 :
142 : nsresult
143 0 : ImageWrapper::GetNativeSizes(nsTArray<IntSize>& aNativeSizes) const
144 : {
145 0 : return mInnerImage->GetNativeSizes(aNativeSizes);
146 : }
147 :
148 : NS_IMETHODIMP
149 0 : ImageWrapper::GetIntrinsicSize(nsSize* aSize)
150 : {
151 0 : return mInnerImage->GetIntrinsicSize(aSize);
152 : }
153 :
154 : NS_IMETHODIMP
155 0 : ImageWrapper::GetIntrinsicRatio(nsSize* aSize)
156 : {
157 0 : return mInnerImage->GetIntrinsicRatio(aSize);
158 : }
159 :
160 : NS_IMETHODIMP_(Orientation)
161 0 : ImageWrapper::GetOrientation()
162 : {
163 0 : return mInnerImage->GetOrientation();
164 : }
165 :
166 : NS_IMETHODIMP
167 24 : ImageWrapper::GetType(uint16_t* aType)
168 : {
169 24 : return mInnerImage->GetType(aType);
170 : }
171 :
172 : NS_IMETHODIMP
173 0 : ImageWrapper::GetAnimated(bool* aAnimated)
174 : {
175 0 : return mInnerImage->GetAnimated(aAnimated);
176 : }
177 :
178 : NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
179 0 : ImageWrapper::GetFrame(uint32_t aWhichFrame,
180 : uint32_t aFlags)
181 : {
182 0 : return mInnerImage->GetFrame(aWhichFrame, aFlags);
183 : }
184 :
185 : NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
186 0 : ImageWrapper::GetFrameAtSize(const IntSize& aSize,
187 : uint32_t aWhichFrame,
188 : uint32_t aFlags)
189 : {
190 0 : return mInnerImage->GetFrameAtSize(aSize, aWhichFrame, aFlags);
191 : }
192 :
193 : NS_IMETHODIMP_(bool)
194 0 : ImageWrapper::WillDrawOpaqueNow()
195 : {
196 0 : return mInnerImage->WillDrawOpaqueNow();
197 : }
198 :
199 : NS_IMETHODIMP_(bool)
200 0 : ImageWrapper::IsImageContainerAvailable(LayerManager* aManager, uint32_t aFlags)
201 : {
202 0 : return mInnerImage->IsImageContainerAvailable(aManager, aFlags);
203 : }
204 :
205 : NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
206 0 : ImageWrapper::GetImageContainer(LayerManager* aManager, uint32_t aFlags)
207 : {
208 0 : return mInnerImage->GetImageContainer(aManager, aFlags);
209 : }
210 :
211 : NS_IMETHODIMP_(DrawResult)
212 0 : ImageWrapper::Draw(gfxContext* aContext,
213 : const nsIntSize& aSize,
214 : const ImageRegion& aRegion,
215 : uint32_t aWhichFrame,
216 : SamplingFilter aSamplingFilter,
217 : const Maybe<SVGImageContext>& aSVGContext,
218 : uint32_t aFlags,
219 : float aOpacity)
220 : {
221 0 : return mInnerImage->Draw(aContext, aSize, aRegion, aWhichFrame,
222 0 : aSamplingFilter, aSVGContext, aFlags, aOpacity);
223 : }
224 :
225 : NS_IMETHODIMP
226 0 : ImageWrapper::StartDecoding(uint32_t aFlags)
227 : {
228 0 : return mInnerImage->StartDecoding(aFlags);
229 : }
230 :
231 : bool
232 0 : ImageWrapper::StartDecodingWithResult(uint32_t aFlags)
233 : {
234 0 : return mInnerImage->StartDecodingWithResult(aFlags);
235 : }
236 :
237 : NS_IMETHODIMP
238 0 : ImageWrapper::RequestDecodeForSize(const nsIntSize& aSize, uint32_t aFlags)
239 : {
240 0 : return mInnerImage->RequestDecodeForSize(aSize, aFlags);
241 : }
242 :
243 : NS_IMETHODIMP
244 0 : ImageWrapper::LockImage()
245 : {
246 0 : MOZ_ASSERT(NS_IsMainThread(),
247 : "Main thread to encourage serialization with UnlockImage");
248 0 : return mInnerImage->LockImage();
249 : }
250 :
251 : NS_IMETHODIMP
252 0 : ImageWrapper::UnlockImage()
253 : {
254 0 : MOZ_ASSERT(NS_IsMainThread(),
255 : "Main thread to encourage serialization with LockImage");
256 0 : return mInnerImage->UnlockImage();
257 : }
258 :
259 : NS_IMETHODIMP
260 0 : ImageWrapper::RequestDiscard()
261 : {
262 0 : return mInnerImage->RequestDiscard();
263 : }
264 :
265 : NS_IMETHODIMP_(void)
266 0 : ImageWrapper::RequestRefresh(const TimeStamp& aTime)
267 : {
268 0 : return mInnerImage->RequestRefresh(aTime);
269 : }
270 :
271 : NS_IMETHODIMP
272 0 : ImageWrapper::GetAnimationMode(uint16_t* aAnimationMode)
273 : {
274 0 : return mInnerImage->GetAnimationMode(aAnimationMode);
275 : }
276 :
277 : NS_IMETHODIMP
278 0 : ImageWrapper::SetAnimationMode(uint16_t aAnimationMode)
279 : {
280 0 : return mInnerImage->SetAnimationMode(aAnimationMode);
281 : }
282 :
283 : NS_IMETHODIMP
284 0 : ImageWrapper::ResetAnimation()
285 : {
286 0 : return mInnerImage->ResetAnimation();
287 : }
288 :
289 : NS_IMETHODIMP_(float)
290 0 : ImageWrapper::GetFrameIndex(uint32_t aWhichFrame)
291 : {
292 0 : return mInnerImage->GetFrameIndex(aWhichFrame);
293 : }
294 :
295 : NS_IMETHODIMP_(int32_t)
296 0 : ImageWrapper::GetFirstFrameDelay()
297 : {
298 0 : return mInnerImage->GetFirstFrameDelay();
299 : }
300 :
301 : NS_IMETHODIMP_(void)
302 0 : ImageWrapper::SetAnimationStartTime(const TimeStamp& aTime)
303 : {
304 0 : mInnerImage->SetAnimationStartTime(aTime);
305 0 : }
306 :
307 : void
308 0 : ImageWrapper::PropagateUseCounters(nsIDocument* aParentDocument)
309 : {
310 0 : mInnerImage->PropagateUseCounters(aParentDocument);
311 0 : }
312 :
313 : nsIntSize
314 0 : ImageWrapper::OptimalImageSizeForDest(const gfxSize& aDest,
315 : uint32_t aWhichFrame,
316 : SamplingFilter aSamplingFilter,
317 : uint32_t aFlags)
318 : {
319 0 : return mInnerImage->OptimalImageSizeForDest(aDest, aWhichFrame,
320 0 : aSamplingFilter, aFlags);
321 : }
322 :
323 : NS_IMETHODIMP_(nsIntRect)
324 0 : ImageWrapper::GetImageSpaceInvalidationRect(const nsIntRect& aRect)
325 : {
326 0 : return mInnerImage->GetImageSpaceInvalidationRect(aRect);
327 : }
328 :
329 : already_AddRefed<imgIContainer>
330 0 : ImageWrapper::Unwrap()
331 : {
332 0 : return mInnerImage->Unwrap();
333 : }
334 :
335 : } // namespace image
336 9 : } // namespace mozilla
|
