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"
27 #include "mozilla/StaticPrefs_image.h"
33 void ImageFactory::Initialize() {}
35 static uint32_t ComputeImageFlags(nsIURI
* uri
, const nsCString
& aMimeType
,
37 // We default to the static globals.
38 bool isDiscardable
= StaticPrefs::image_mem_discardable();
39 bool doDecodeImmediately
= StaticPrefs::image_decode_immediately_enabled();
41 // We want UI to be as snappy as possible and not to flicker. Disable
42 // discarding for chrome URLS.
43 if (uri
->SchemeIs("chrome")) {
44 isDiscardable
= false;
47 // We don't want resources like the "loading" icon to be discardable either.
48 if (uri
->SchemeIs("resource")) {
49 isDiscardable
= false;
52 // For multipart/x-mixed-replace, we basically want a direct channel to the
53 // decoder. Disable everything for this case.
55 isDiscardable
= false;
58 // We have all the information we need.
59 uint32_t imageFlags
= Image::INIT_FLAG_NONE
;
61 imageFlags
|= Image::INIT_FLAG_DISCARDABLE
;
63 if (doDecodeImmediately
) {
64 imageFlags
|= Image::INIT_FLAG_DECODE_IMMEDIATELY
;
67 imageFlags
|= Image::INIT_FLAG_TRANSIENT
;
70 // Synchronously decode metadata (including size) if we have a data URI since
71 // the data is immediately available.
72 if (uri
->SchemeIs("data")) {
73 imageFlags
|= Image::INIT_FLAG_SYNC_LOAD
;
80 static void NotifyImageLoading(nsIURI
* aURI
) {
81 if (!NS_IsMainThread()) {
82 nsCOMPtr
<nsIURI
> uri(aURI
);
83 nsCOMPtr
<nsIRunnable
> ev
= NS_NewRunnableFunction(
84 "NotifyImageLoading", [uri
]() -> void { NotifyImageLoading(uri
); });
85 SystemGroup::Dispatch(TaskCategory::Other
, ev
.forget());
89 nsCOMPtr
<nsIObserverService
> obs
= services::GetObserverService();
90 NS_WARNING_ASSERTION(obs
, "Can't get an observer service handle");
94 obs
->NotifyObservers(nullptr, "image-loading",
95 NS_ConvertUTF8toUTF16(spec
).get());
101 already_AddRefed
<Image
> ImageFactory::CreateImage(
102 nsIRequest
* aRequest
, ProgressTracker
* aProgressTracker
,
103 const nsCString
& aMimeType
, nsIURI
* aURI
, bool aIsMultiPart
,
104 uint32_t aInnerWindowId
) {
105 // Compute the image's initialization flags.
106 uint32_t imageFlags
= ComputeImageFlags(aURI
, aMimeType
, aIsMultiPart
);
109 // Record the image load for startup performance testing.
110 if (aURI
->SchemeIs("resource") || aURI
->SchemeIs("chrome")) {
111 NotifyImageLoading(aURI
);
115 // Select the type of image to create based on MIME type.
116 if (aMimeType
.EqualsLiteral(IMAGE_SVG_XML
)) {
117 return CreateVectorImage(aRequest
, aProgressTracker
, aMimeType
, aURI
,
118 imageFlags
, aInnerWindowId
);
120 return CreateRasterImage(aRequest
, aProgressTracker
, aMimeType
, aURI
,
121 imageFlags
, aInnerWindowId
);
125 // Marks an image as having an error before returning it.
126 template <typename T
>
127 static already_AddRefed
<Image
> BadImage(const char* aMessage
,
129 aImage
->SetHasError();
130 return aImage
.forget();
134 already_AddRefed
<Image
> ImageFactory::CreateAnonymousImage(
135 const nsCString
& aMimeType
, uint32_t aSizeHint
/* = 0 */) {
138 RefPtr
<RasterImage
> newImage
= new RasterImage();
140 RefPtr
<ProgressTracker
> newTracker
= new ProgressTracker();
141 newTracker
->SetImage(newImage
);
142 newImage
->SetProgressTracker(newTracker
);
144 rv
= newImage
->Init(aMimeType
.get(), Image::INIT_FLAG_SYNC_LOAD
);
146 return BadImage("RasterImage::Init failed", newImage
);
149 rv
= newImage
->SetSourceSizeHint(aSizeHint
);
151 return BadImage("RasterImage::SetSourceSizeHint failed", newImage
);
154 return newImage
.forget();
158 already_AddRefed
<MultipartImage
> ImageFactory::CreateMultipartImage(
159 Image
* aFirstPart
, ProgressTracker
* aProgressTracker
) {
160 MOZ_ASSERT(aFirstPart
);
161 MOZ_ASSERT(aProgressTracker
);
163 RefPtr
<MultipartImage
> newImage
= new MultipartImage(aFirstPart
);
164 aProgressTracker
->SetImage(newImage
);
165 newImage
->SetProgressTracker(aProgressTracker
);
169 return newImage
.forget();
172 int32_t SaturateToInt32(int64_t val
) {
180 return static_cast<int32_t>(val
);
183 uint32_t GetContentSize(nsIRequest
* aRequest
) {
184 nsCOMPtr
<nsIChannel
> channel(do_QueryInterface(aRequest
));
187 nsresult rv
= channel
->GetContentLength(&size
);
188 if (NS_SUCCEEDED(rv
)) {
189 return std::max(SaturateToInt32(size
), 0);
193 // Use the file size as a size hint for file channels.
194 nsCOMPtr
<nsIFileChannel
> fileChannel(do_QueryInterface(aRequest
));
196 nsCOMPtr
<nsIFile
> file
;
197 nsresult rv
= fileChannel
->GetFile(getter_AddRefs(file
));
198 if (NS_SUCCEEDED(rv
)) {
200 rv
= file
->GetFileSize(&filesize
);
201 if (NS_SUCCEEDED(rv
)) {
202 return std::max(SaturateToInt32(filesize
), 0);
207 // Fallback - neither http nor file. We'll use dynamic allocation.
212 already_AddRefed
<Image
> ImageFactory::CreateRasterImage(
213 nsIRequest
* aRequest
, ProgressTracker
* aProgressTracker
,
214 const nsCString
& aMimeType
, nsIURI
* aURI
, uint32_t aImageFlags
,
215 uint32_t aInnerWindowId
) {
216 MOZ_ASSERT(aProgressTracker
);
220 RefPtr
<RasterImage
> newImage
= new RasterImage(aURI
);
221 aProgressTracker
->SetImage(newImage
);
222 newImage
->SetProgressTracker(aProgressTracker
);
224 rv
= newImage
->Init(aMimeType
.get(), aImageFlags
);
226 return BadImage("RasterImage::Init failed", newImage
);
229 newImage
->SetInnerWindowID(aInnerWindowId
);
231 rv
= newImage
->SetSourceSizeHint(GetContentSize(aRequest
));
233 return BadImage("RasterImage::SetSourceSizeHint failed", newImage
);
236 return newImage
.forget();
240 already_AddRefed
<Image
> ImageFactory::CreateVectorImage(
241 nsIRequest
* aRequest
, ProgressTracker
* aProgressTracker
,
242 const nsCString
& aMimeType
, nsIURI
* aURI
, uint32_t aImageFlags
,
243 uint32_t aInnerWindowId
) {
244 MOZ_ASSERT(aProgressTracker
);
248 RefPtr
<VectorImage
> newImage
= new VectorImage(aURI
);
249 aProgressTracker
->SetImage(newImage
);
250 newImage
->SetProgressTracker(aProgressTracker
);
252 rv
= newImage
->Init(aMimeType
.get(), aImageFlags
);
254 return BadImage("VectorImage::Init failed", newImage
);
257 newImage
->SetInnerWindowID(aInnerWindowId
);
259 rv
= newImage
->OnStartRequest(aRequest
);
261 return BadImage("VectorImage::OnStartRequest failed", newImage
);
264 return newImage
.forget();
268 } // namespace mozilla