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 "gfxPrefs.h"
  28
  29 namespace mozilla {
  30 namespace image {
  31
  32 /*static*/ void
  33 ImageFactory::Initialize()
  34 { }
  35
  36 static uint32_t
  37 ComputeImageFlags(ImageURL* uri, const nsCString& aMimeType, bool isMultiPart)
  38 {
  39   nsresult rv;
  40
  41   // We default to the static globals.
  42   bool isDiscardable = gfxPrefs::ImageMemDiscardable();
  43   bool doDecodeImmediately = gfxPrefs::ImageDecodeImmediatelyEnabled();
  44
  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;
  51   }
  52
  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;
  58   }
  59
  60   // For multipart/x-mixed-replace, we basically want a direct channel to the
  61   // decoder. Disable everything for this case.
  62   if (isMultiPart) {
  63     isDiscardable = false;
  64   }
  65
  66   // We have all the information we need.
  67   uint32_t imageFlags = Image::INIT_FLAG_NONE;
  68   if (isDiscardable) {
  69     imageFlags |= Image::INIT_FLAG_DISCARDABLE;
  70   }
  71   if (doDecodeImmediately) {
  72     imageFlags |= Image::INIT_FLAG_DECODE_IMMEDIATELY;
  73   }
  74   if (isMultiPart) {
  75     imageFlags |= Image::INIT_FLAG_TRANSIENT;
  76   }
  77
  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;
  84   }
  85
  86   return imageFlags;
  87 }
  88
  89 #ifdef DEBUG
  90 static void
  91 NotifyImageLoading(ImageURL* aURI)
  92 {
  93   if (!NS_IsMainThread()) {
  94     RefPtr<ImageURL> uri(aURI);
  95     nsCOMPtr<nsIRunnable> ev =
  96       NS_NewRunnableFunction("NotifyImageLoading", [uri] () -> void {
  97         NotifyImageLoading(uri);
  98     });
  99     SystemGroup::Dispatch(TaskCategory::Other, ev.forget());
 100     return;
 101   }
 102
 103   nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
 104   NS_WARNING_ASSERTION(obs, "Can't get an observer service handle");
 105   if (obs) {
 106     nsAutoCString spec;
 107     aURI->GetSpec(spec);
 108     obs->NotifyObservers(nullptr, "image-loading", NS_ConvertUTF8toUTF16(spec).get());
 109   }
 110 }
 111 #endif
 112
 113 /* static */ already_AddRefed<Image>
 114 ImageFactory::CreateImage(nsIRequest* aRequest,
 115                           ProgressTracker* aProgressTracker,
 116                           const nsCString& aMimeType,
 117                           ImageURL* aURI,
 118                           bool aIsMultiPart,
 119                           uint32_t aInnerWindowId)
 120 {
 121   MOZ_ASSERT(gfxPrefs::SingletonExists(),
 122              "Pref observers should have been initialized already");
 123
 124   // Compute the image's initialization flags.
 125   uint32_t imageFlags = ComputeImageFlags(aURI, aMimeType, aIsMultiPart);
 126
 127 #ifdef DEBUG
 128   // Record the image load for startup performance testing.
 129   bool match = false;
 130   if ((NS_SUCCEEDED(aURI->SchemeIs("resource", &match)) && match) ||
 131       (NS_SUCCEEDED(aURI->SchemeIs("chrome", &match)) && match)) {
 132     NotifyImageLoading(aURI);
 133   }
 134 #endif
 135
 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);
 140   } else {
 141     return CreateRasterImage(aRequest, aProgressTracker, aMimeType,
 142                              aURI, imageFlags, aInnerWindowId);
 143   }
 144 }
 145
 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)
 150 {
 151   aImage->SetHasError();
 152   return aImage.forget();
 153 }
 154
 155 static void
 156 SetSourceSizeHint(RasterImage* aImage, uint32_t aSize)
 157 {
 158   // Pass anything usable on so that the RasterImage can preallocate
 159   // its source buffer.
 160   if (aSize == 0) {
 161     return;
 162   }
 163
 164   // Bound by something reasonable
 165   uint32_t sizeHint = std::min<uint32_t>(aSize, 20000000);
 166   nsresult rv = aImage->SetSourceSizeHint(sizeHint);
 167   if (NS_FAILED(rv)) {
 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!");
 174     }
 175   }
 176 }
 177
 178 /* static */ already_AddRefed<Image>
 179 ImageFactory::CreateAnonymousImage(const nsCString& aMimeType,
 180                                    uint32_t aSizeHint /* = 0 */)
 181 {
 182   nsresult rv;
 183
 184   RefPtr<RasterImage> newImage = new RasterImage();
 185
 186   RefPtr<ProgressTracker> newTracker = new ProgressTracker();
 187   newTracker->SetImage(newImage);
 188   newImage->SetProgressTracker(newTracker);
 189
 190   rv = newImage->Init(aMimeType.get(), Image::INIT_FLAG_SYNC_LOAD);
 191   if (NS_FAILED(rv)) {
 192     return BadImage("RasterImage::Init failed", newImage);
 193   }
 194
 195   SetSourceSizeHint(newImage, aSizeHint);
 196   return newImage.forget();
 197 }
 198
 199 /* static */ already_AddRefed<MultipartImage>
 200 ImageFactory::CreateMultipartImage(Image* aFirstPart,
 201                                    ProgressTracker* aProgressTracker)
 202 {
 203   MOZ_ASSERT(aFirstPart);
 204   MOZ_ASSERT(aProgressTracker);
 205
 206   RefPtr<MultipartImage> newImage = new MultipartImage(aFirstPart);
 207   aProgressTracker->SetImage(newImage);
 208   newImage->SetProgressTracker(aProgressTracker);
 209
 210   newImage->Init();
 211
 212   return newImage.forget();
 213 }
 214
 215 int32_t
 216 SaturateToInt32(int64_t val)
 217 {
 218   if (val > INT_MAX) {
 219     return INT_MAX;
 220   }
 221   if (val < INT_MIN) {
 222     return INT_MIN;
 223   }
 224
 225   return static_cast<int32_t>(val);
 226 }
 227
 228 uint32_t
 229 GetContentSize(nsIRequest* aRequest)
 230 {
 231   nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
 232   if (channel) {
 233     int64_t size;
 234     nsresult rv = channel->GetContentLength(&size);
 235     if (NS_SUCCEEDED(rv)) {
 236       return std::max(SaturateToInt32(size), 0);
 237     }
 238   }
 239
 240   // Use the file size as a size hint for file channels.
 241   nsCOMPtr<nsIFileChannel> fileChannel(do_QueryInterface(aRequest));
 242   if (fileChannel) {
 243     nsCOMPtr<nsIFile> file;
 244     nsresult rv = fileChannel->GetFile(getter_AddRefs(file));
 245     if (NS_SUCCEEDED(rv)) {
 246       int64_t filesize;
 247       rv = file->GetFileSize(&filesize);
 248       if (NS_SUCCEEDED(rv)) {
 249         return std::max(SaturateToInt32(filesize), 0);
 250       }
 251     }
 252   }
 253
 254   // Fallback - neither http nor file. We'll use dynamic allocation.
 255   return 0;
 256 }
 257
 258 /* static */ already_AddRefed<Image>
 259 ImageFactory::CreateRasterImage(nsIRequest* aRequest,
 260                                 ProgressTracker* aProgressTracker,
 261                                 const nsCString& aMimeType,
 262                                 ImageURL* aURI,
 263                                 uint32_t aImageFlags,
 264                                 uint32_t aInnerWindowId)
 265 {
 266   MOZ_ASSERT(aProgressTracker);
 267
 268   nsresult rv;
 269
 270   RefPtr<RasterImage> newImage = new RasterImage(aURI);
 271   aProgressTracker->SetImage(newImage);
 272   newImage->SetProgressTracker(aProgressTracker);
 273
 274   rv = newImage->Init(aMimeType.get(), aImageFlags);
 275   if (NS_FAILED(rv)) {
 276     return BadImage("RasterImage::Init failed", newImage);
 277   }
 278
 279   newImage->SetInnerWindowID(aInnerWindowId);
 280
 281   SetSourceSizeHint(newImage, GetContentSize(aRequest));
 282   return newImage.forget();
 283 }
 284
 285 /* static */ already_AddRefed<Image>
 286 ImageFactory::CreateVectorImage(nsIRequest* aRequest,
 287                                 ProgressTracker* aProgressTracker,
 288                                 const nsCString& aMimeType,
 289                                 ImageURL* aURI,
 290                                 uint32_t aImageFlags,
 291                                 uint32_t aInnerWindowId)
 292 {
 293   MOZ_ASSERT(aProgressTracker);
 294
 295   nsresult rv;
 296
 297   RefPtr<VectorImage> newImage = new VectorImage(aURI);
 298   aProgressTracker->SetImage(newImage);
 299   newImage->SetProgressTracker(aProgressTracker);
 300
 301   rv = newImage->Init(aMimeType.get(), aImageFlags);
 302   if (NS_FAILED(rv)) {
 303     return BadImage("VectorImage::Init failed", newImage);
 304   }
 305
 306   newImage->SetInnerWindowID(aInnerWindowId);
 307
 308   rv = newImage->OnStartRequest(aRequest, nullptr);
 309   if (NS_FAILED(rv)) {
 310     return BadImage("VectorImage::OnStartRequest failed", newImage);
 311   }
 312
 313   return newImage.forget();
 314 }
 315
 316 } // namespace image
 317 } // namespace mozilla