image/ImageFactory.cpp

   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 #include "ImageFactory.h"
   8
   9 #include <algorithm>
  10
  11 #include "mozilla/Likely.h"
  12
  13 #include "nsIHttpChannel.h"
  14 #include "nsIFileChannel.h"
  15 #include "nsIFile.h"
  16 #include "nsMimeTypes.h"
  17 #include "nsIRequest.h"
  18
  19 #include "MultipartImage.h"
  20 #include "RasterImage.h"
  21 #include "VectorImage.h"
  22 #include "Image.h"
  23 #include "nsMediaFragmentURIParser.h"
  24 #include "nsContentUtils.h"
  25 #include "nsIScriptSecurityManager.h"
  26
  27 #include "mozilla/StaticPrefs_image.h"
  28
  29 namespace mozilla {
  30 namespace image {
  31
  32 /*static*/
  33 void ImageFactory::Initialize() {}
  34
  35 static uint32_t ComputeImageFlags(nsIURI* uri, const nsCString& aMimeType,
  36                                   bool isMultiPart) {
  37   // We default to the static globals.
  38   bool isDiscardable = StaticPrefs::image_mem_discardable();
  39   bool doDecodeImmediately = StaticPrefs::image_decode_immediately_enabled();
  40
  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;
  45   }
  46
  47   // We don't want resources like the "loading" icon to be discardable either.
  48   if (uri->SchemeIs("resource")) {
  49     isDiscardable = false;
  50   }
  51
  52   // For multipart/x-mixed-replace, we basically want a direct channel to the
  53   // decoder. Disable everything for this case.
  54   if (isMultiPart) {
  55     isDiscardable = false;
  56   }
  57
  58   // We have all the information we need.
  59   uint32_t imageFlags = Image::INIT_FLAG_NONE;
  60   if (isDiscardable) {
  61     imageFlags |= Image::INIT_FLAG_DISCARDABLE;
  62   }
  63   if (doDecodeImmediately) {
  64     imageFlags |= Image::INIT_FLAG_DECODE_IMMEDIATELY;
  65   }
  66   if (isMultiPart) {
  67     imageFlags |= Image::INIT_FLAG_TRANSIENT;
  68   }
  69
  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;
  74   }
  75
  76   return imageFlags;
  77 }
  78
  79 #ifdef DEBUG
  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());
  86     return;
  87   }
  88
  89   nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
  90   NS_WARNING_ASSERTION(obs, "Can't get an observer service handle");
  91   if (obs) {
  92     nsAutoCString spec;
  93     aURI->GetSpec(spec);
  94     obs->NotifyObservers(nullptr, "image-loading",
  95                          NS_ConvertUTF8toUTF16(spec).get());
  96   }
  97 }
  98 #endif
  99
 100 /* static */
 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);
 107
 108 #ifdef DEBUG
 109   // Record the image load for startup performance testing.
 110   if (aURI->SchemeIs("resource") || aURI->SchemeIs("chrome")) {
 111     NotifyImageLoading(aURI);
 112   }
 113 #endif
 114
 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);
 119   } else {
 120     return CreateRasterImage(aRequest, aProgressTracker, aMimeType, aURI,
 121                              imageFlags, aInnerWindowId);
 122   }
 123 }
 124
 125 // Marks an image as having an error before returning it.
 126 template <typename T>
 127 static already_AddRefed<Image> BadImage(const char* aMessage,
 128                                         RefPtr<T>& aImage) {
 129   aImage->SetHasError();
 130   return aImage.forget();
 131 }
 132
 133 /* static */
 134 already_AddRefed<Image> ImageFactory::CreateAnonymousImage(
 135     const nsCString& aMimeType, uint32_t aSizeHint /* = 0 */) {
 136   nsresult rv;
 137
 138   RefPtr<RasterImage> newImage = new RasterImage();
 139
 140   RefPtr<ProgressTracker> newTracker = new ProgressTracker();
 141   newTracker->SetImage(newImage);
 142   newImage->SetProgressTracker(newTracker);
 143
 144   rv = newImage->Init(aMimeType.get(), Image::INIT_FLAG_SYNC_LOAD);
 145   if (NS_FAILED(rv)) {
 146     return BadImage("RasterImage::Init failed", newImage);
 147   }
 148
 149   rv = newImage->SetSourceSizeHint(aSizeHint);
 150   if (NS_FAILED(rv)) {
 151     return BadImage("RasterImage::SetSourceSizeHint failed", newImage);
 152   }
 153
 154   return newImage.forget();
 155 }
 156
 157 /* static */
 158 already_AddRefed<MultipartImage> ImageFactory::CreateMultipartImage(
 159     Image* aFirstPart, ProgressTracker* aProgressTracker) {
 160   MOZ_ASSERT(aFirstPart);
 161   MOZ_ASSERT(aProgressTracker);
 162
 163   RefPtr<MultipartImage> newImage = new MultipartImage(aFirstPart);
 164   aProgressTracker->SetImage(newImage);
 165   newImage->SetProgressTracker(aProgressTracker);
 166
 167   newImage->Init();
 168
 169   return newImage.forget();
 170 }
 171
 172 int32_t SaturateToInt32(int64_t val) {
 173   if (val > INT_MAX) {
 174     return INT_MAX;
 175   }
 176   if (val < INT_MIN) {
 177     return INT_MIN;
 178   }
 179
 180   return static_cast<int32_t>(val);
 181 }
 182
 183 uint32_t GetContentSize(nsIRequest* aRequest) {
 184   nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
 185   if (channel) {
 186     int64_t size;
 187     nsresult rv = channel->GetContentLength(&size);
 188     if (NS_SUCCEEDED(rv)) {
 189       return std::max(SaturateToInt32(size), 0);
 190     }
 191   }
 192
 193   // Use the file size as a size hint for file channels.
 194   nsCOMPtr<nsIFileChannel> fileChannel(do_QueryInterface(aRequest));
 195   if (fileChannel) {
 196     nsCOMPtr<nsIFile> file;
 197     nsresult rv = fileChannel->GetFile(getter_AddRefs(file));
 198     if (NS_SUCCEEDED(rv)) {
 199       int64_t filesize;
 200       rv = file->GetFileSize(&filesize);
 201       if (NS_SUCCEEDED(rv)) {
 202         return std::max(SaturateToInt32(filesize), 0);
 203       }
 204     }
 205   }
 206
 207   // Fallback - neither http nor file. We'll use dynamic allocation.
 208   return 0;
 209 }
 210
 211 /* static */
 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);
 217
 218   nsresult rv;
 219
 220   RefPtr<RasterImage> newImage = new RasterImage(aURI);
 221   aProgressTracker->SetImage(newImage);
 222   newImage->SetProgressTracker(aProgressTracker);
 223
 224   rv = newImage->Init(aMimeType.get(), aImageFlags);
 225   if (NS_FAILED(rv)) {
 226     return BadImage("RasterImage::Init failed", newImage);
 227   }
 228
 229   newImage->SetInnerWindowID(aInnerWindowId);
 230
 231   rv = newImage->SetSourceSizeHint(GetContentSize(aRequest));
 232   if (NS_FAILED(rv)) {
 233     return BadImage("RasterImage::SetSourceSizeHint failed", newImage);
 234   }
 235
 236   return newImage.forget();
 237 }
 238
 239 /* static */
 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);
 245
 246   nsresult rv;
 247
 248   RefPtr<VectorImage> newImage = new VectorImage(aURI);
 249   aProgressTracker->SetImage(newImage);
 250   newImage->SetProgressTracker(aProgressTracker);
 251
 252   rv = newImage->Init(aMimeType.get(), aImageFlags);
 253   if (NS_FAILED(rv)) {
 254     return BadImage("VectorImage::Init failed", newImage);
 255   }
 256
 257   newImage->SetInnerWindowID(aInnerWindowId);
 258
 259   rv = newImage->OnStartRequest(aRequest);
 260   if (NS_FAILED(rv)) {
 261     return BadImage("VectorImage::OnStartRequest failed", newImage);
 262   }
 263
 264   return newImage.forget();
 265 }
 266
 267 }  // namespace image
 268 }  // namespace mozilla