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 #include "ImageFactory.h"
11 #include "mozilla/Likely.h"
13 #include "nsIHttpChannel.h"
14 #include "nsIFileChannel.h"
16 #include "nsMimeTypes.h"
17 #include "nsIRequest.h"
19 #include "MultipartImage.h"
20 #include "RasterImage.h"
21 #include "VectorImage.h"
23 #include "nsMediaFragmentURIParser.h"
24 #include "nsContentUtils.h"
25 #include "nsIScriptSecurityManager.h"
33 ImageFactory::Initialize()
37 ComputeImageFlags(ImageURL
* uri
, const nsCString
& aMimeType
, bool isMultiPart
)
41 // We default to the static globals.
42 bool isDiscardable
= gfxPrefs::ImageMemDiscardable();
43 bool doDecodeImmediately
= gfxPrefs::ImageDecodeImmediatelyEnabled();
45 // We want UI to be as snappy as possible and not to flicker. Disable
46 // discarding for chrome URLS.
47 bool isChrome
= false;
48 rv
= uri
->SchemeIs("chrome", &isChrome
);
49 if (NS_SUCCEEDED(rv
) && isChrome
) {
50 isDiscardable
= false;
53 // We don't want resources like the "loading" icon to be discardable either.
54 bool isResource
= false;
55 rv
= uri
->SchemeIs("resource", &isResource
);
56 if (NS_SUCCEEDED(rv
) && isResource
) {
57 isDiscardable
= false;
60 // For multipart/x-mixed-replace, we basically want a direct channel to the
61 // decoder. Disable everything for this case.
63 isDiscardable
= false;
66 // We have all the information we need.
67 uint32_t imageFlags
= Image::INIT_FLAG_NONE
;
69 imageFlags
|= Image::INIT_FLAG_DISCARDABLE
;
71 if (doDecodeImmediately
) {
72 imageFlags
|= Image::INIT_FLAG_DECODE_IMMEDIATELY
;
75 imageFlags
|= Image::INIT_FLAG_TRANSIENT
;
78 // Synchronously decode metadata (including size) if we have a data URI since
79 // the data is immediately available.
80 bool isDataURI
= false;
81 rv
= uri
->SchemeIs("data", &isDataURI
);
82 if (NS_SUCCEEDED(rv
) && isDataURI
) {
83 imageFlags
|= Image::INIT_FLAG_SYNC_LOAD
;
91 NotifyImageLoading(ImageURL
* aURI
)
93 if (!NS_IsMainThread()) {
94 RefPtr
<ImageURL
> uri(aURI
);
95 nsCOMPtr
<nsIRunnable
> ev
=
96 NS_NewRunnableFunction("NotifyImageLoading", [uri
] () -> void {
97 NotifyImageLoading(uri
);
99 SystemGroup::Dispatch(TaskCategory::Other
, ev
.forget());
103 nsCOMPtr
<nsIObserverService
> obs
= services::GetObserverService();
104 NS_WARNING_ASSERTION(obs
, "Can't get an observer service handle");
108 obs
->NotifyObservers(nullptr, "image-loading", NS_ConvertUTF8toUTF16(spec
).get());
113 /* static */ already_AddRefed
<Image
>
114 ImageFactory::CreateImage(nsIRequest
* aRequest
,
115 ProgressTracker
* aProgressTracker
,
116 const nsCString
& aMimeType
,
119 uint32_t aInnerWindowId
)
121 MOZ_ASSERT(gfxPrefs::SingletonExists(),
122 "Pref observers should have been initialized already");
124 // Compute the image's initialization flags.
125 uint32_t imageFlags
= ComputeImageFlags(aURI
, aMimeType
, aIsMultiPart
);
128 // Record the image load for startup performance testing.
130 if ((NS_SUCCEEDED(aURI
->SchemeIs("resource", &match
)) && match
) ||
131 (NS_SUCCEEDED(aURI
->SchemeIs("chrome", &match
)) && match
)) {
132 NotifyImageLoading(aURI
);
136 // Select the type of image to create based on MIME type.
137 if (aMimeType
.EqualsLiteral(IMAGE_SVG_XML
)) {
138 return CreateVectorImage(aRequest
, aProgressTracker
, aMimeType
,
139 aURI
, imageFlags
, aInnerWindowId
);
141 return CreateRasterImage(aRequest
, aProgressTracker
, aMimeType
,
142 aURI
, imageFlags
, aInnerWindowId
);
146 // Marks an image as having an error before returning it.
147 template <typename T
>
148 static already_AddRefed
<Image
>
149 BadImage(const char* aMessage
, RefPtr
<T
>& aImage
)
151 aImage
->SetHasError();
152 return aImage
.forget();
156 SetSourceSizeHint(RasterImage
* aImage
, uint32_t aSize
)
158 // Pass anything usable on so that the RasterImage can preallocate
159 // its source buffer.
164 // Bound by something reasonable
165 uint32_t sizeHint
= std::min
<uint32_t>(aSize
, 20000000);
166 nsresult rv
= aImage
->SetSourceSizeHint(sizeHint
);
168 // Flush memory, try to get some back, and try again.
169 rv
= nsMemory::HeapMinimize(true);
170 nsresult rv2
= aImage
->SetSourceSizeHint(sizeHint
);
171 // If we've still failed at this point, things are going downhill.
172 if (NS_FAILED(rv
) || NS_FAILED(rv2
)) {
173 NS_WARNING("About to hit OOM in imagelib!");
178 /* static */ already_AddRefed
<Image
>
179 ImageFactory::CreateAnonymousImage(const nsCString
& aMimeType
,
180 uint32_t aSizeHint
/* = 0 */)
184 RefPtr
<RasterImage
> newImage
= new RasterImage();
186 RefPtr
<ProgressTracker
> newTracker
= new ProgressTracker();
187 newTracker
->SetImage(newImage
);
188 newImage
->SetProgressTracker(newTracker
);
190 rv
= newImage
->Init(aMimeType
.get(), Image::INIT_FLAG_SYNC_LOAD
);
192 return BadImage("RasterImage::Init failed", newImage
);
195 SetSourceSizeHint(newImage
, aSizeHint
);
196 return newImage
.forget();
199 /* static */ already_AddRefed
<MultipartImage
>
200 ImageFactory::CreateMultipartImage(Image
* aFirstPart
,
201 ProgressTracker
* aProgressTracker
)
203 MOZ_ASSERT(aFirstPart
);
204 MOZ_ASSERT(aProgressTracker
);
206 RefPtr
<MultipartImage
> newImage
= new MultipartImage(aFirstPart
);
207 aProgressTracker
->SetImage(newImage
);
208 newImage
->SetProgressTracker(aProgressTracker
);
212 return newImage
.forget();
216 SaturateToInt32(int64_t val
)
225 return static_cast<int32_t>(val
);
229 GetContentSize(nsIRequest
* aRequest
)
231 nsCOMPtr
<nsIChannel
> channel(do_QueryInterface(aRequest
));
234 nsresult rv
= channel
->GetContentLength(&size
);
235 if (NS_SUCCEEDED(rv
)) {
236 return std::max(SaturateToInt32(size
), 0);
240 // Use the file size as a size hint for file channels.
241 nsCOMPtr
<nsIFileChannel
> fileChannel(do_QueryInterface(aRequest
));
243 nsCOMPtr
<nsIFile
> file
;
244 nsresult rv
= fileChannel
->GetFile(getter_AddRefs(file
));
245 if (NS_SUCCEEDED(rv
)) {
247 rv
= file
->GetFileSize(&filesize
);
248 if (NS_SUCCEEDED(rv
)) {
249 return std::max(SaturateToInt32(filesize
), 0);
254 // Fallback - neither http nor file. We'll use dynamic allocation.
258 /* static */ already_AddRefed
<Image
>
259 ImageFactory::CreateRasterImage(nsIRequest
* aRequest
,
260 ProgressTracker
* aProgressTracker
,
261 const nsCString
& aMimeType
,
263 uint32_t aImageFlags
,
264 uint32_t aInnerWindowId
)
266 MOZ_ASSERT(aProgressTracker
);
270 RefPtr
<RasterImage
> newImage
= new RasterImage(aURI
);
271 aProgressTracker
->SetImage(newImage
);
272 newImage
->SetProgressTracker(aProgressTracker
);
274 rv
= newImage
->Init(aMimeType
.get(), aImageFlags
);
276 return BadImage("RasterImage::Init failed", newImage
);
279 newImage
->SetInnerWindowID(aInnerWindowId
);
281 SetSourceSizeHint(newImage
, GetContentSize(aRequest
));
282 return newImage
.forget();
285 /* static */ already_AddRefed
<Image
>
286 ImageFactory::CreateVectorImage(nsIRequest
* aRequest
,
287 ProgressTracker
* aProgressTracker
,
288 const nsCString
& aMimeType
,
290 uint32_t aImageFlags
,
291 uint32_t aInnerWindowId
)
293 MOZ_ASSERT(aProgressTracker
);
297 RefPtr
<VectorImage
> newImage
= new VectorImage(aURI
);
298 aProgressTracker
->SetImage(newImage
);
299 newImage
->SetProgressTracker(aProgressTracker
);
301 rv
= newImage
->Init(aMimeType
.get(), aImageFlags
);
303 return BadImage("VectorImage::Init failed", newImage
);
306 newImage
->SetInnerWindowID(aInnerWindowId
);
308 rv
= newImage
->OnStartRequest(aRequest
, nullptr);
310 return BadImage("VectorImage::OnStartRequest failed", newImage
);
313 return newImage
.forget();
317 } // namespace mozilla