The Tor Browser: image/src/ImageFactory.cpp@b8a032363ba2 (annotated)

image/src/ImageFactory.cpp@b8a032363ba2 (annotated)

image/src/ImageFactory.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include <algorithm>
 #include "mozilla/Preferences.h"
 #include "mozilla/Likely.h"
 #include "nsIHttpChannel.h"
 #include "nsIFileChannel.h"
 #include "nsIFile.h"
 #include "nsMimeTypes.h"
 #include "nsIRequest.h"
 #include "RasterImage.h"
 #include "VectorImage.h"
 #include "Image.h"
 #include "nsMediaFragmentURIParser.h"
 #include "nsContentUtils.h"
 #include "nsIScriptSecurityManager.h"
 #include "ImageFactory.h"
 #include "gfxPrefs.h"
 namespace mozilla {
 namespace image {
 // Global preferences related to image containers.
 static bool gInitializedPrefCaches = false;
 static bool gDecodeOnDraw = false;
 static bool gDiscardable = false;
 static bool gEnableMozSampleSize = false;
 /*static*/ void
 ImageFactory::Initialize()
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!gInitializedPrefCaches) {
     // Initialize the graphics preferences
     gfxPrefs::GetSingleton();
     Preferences::AddBoolVarCache(&gDiscardable, "image.mem.discardable");
     Preferences::AddBoolVarCache(&gDecodeOnDraw, "image.mem.decodeondraw");
     Preferences::AddBoolVarCache(&gEnableMozSampleSize, "image.mozsamplesize.enabled");
     gInitializedPrefCaches = true;
   }
 }
 static uint32_t
 ComputeImageFlags(ImageURL* uri, bool isMultiPart)
 {
   nsresult rv;
   // We default to the static globals.
   bool isDiscardable = gDiscardable;
   bool doDecodeOnDraw = gDecodeOnDraw;
   // We want UI to be as snappy as possible and not to flicker. Disable discarding
   // and decode-on-draw for chrome URLS.
   bool isChrome = false;
   rv = uri->SchemeIs("chrome", &isChrome);
   if (NS_SUCCEEDED(rv) && isChrome)
     isDiscardable = doDecodeOnDraw = false;
   // We don't want resources like the "loading" icon to be discardable or
   // decode-on-draw either.
   bool isResource = false;
   rv = uri->SchemeIs("resource", &isResource);
   if (NS_SUCCEEDED(rv) && isResource)
     isDiscardable = doDecodeOnDraw = false;
   // For multipart/x-mixed-replace, we basically want a direct channel to the
   // decoder. Disable both for this case as well.
   if (isMultiPart)
     isDiscardable = doDecodeOnDraw = false;
   // We have all the information we need.
   uint32_t imageFlags = Image::INIT_FLAG_NONE;
   if (isDiscardable)
     imageFlags |= Image::INIT_FLAG_DISCARDABLE;
   if (doDecodeOnDraw)
     imageFlags |= Image::INIT_FLAG_DECODE_ON_DRAW;
   if (isMultiPart)
     imageFlags |= Image::INIT_FLAG_MULTIPART;
   return imageFlags;
 }
 /* static */ bool
 ImageFactory::CanRetargetOnDataAvailable(ImageURL* aURI, bool aIsMultiPart)
 {
   // We can't retarget OnDataAvailable safely in cases where we aren't storing
   // source data (and thus need to sync decode in ODA) because allocating frames
   // off-main-thread is currently not possible and we don't have a workaround in
   // place yet. (See bug 967985.) For now, we detect those cases and refuse to
   // retarget. When the problem is fixed, this function can be removed.
   if (aIsMultiPart) {
     return false;
   }
   uint32_t imageFlags = ComputeImageFlags(aURI, aIsMultiPart);
   if (!(imageFlags & Image::INIT_FLAG_DISCARDABLE) &&
       !(imageFlags & Image::INIT_FLAG_DECODE_ON_DRAW)) {
     return false;
   }
   return true;
 }
 /* static */ already_AddRefed<Image>
 ImageFactory::CreateImage(nsIRequest* aRequest,
                           imgStatusTracker* aStatusTracker,
                           const nsCString& aMimeType,
                           ImageURL* aURI,
                           bool aIsMultiPart,
                           uint32_t aInnerWindowId)
 {
   MOZ_ASSERT(gInitializedPrefCaches,
              "Pref observers should have been initialized already");
   // Compute the image's initialization flags.
   uint32_t imageFlags = ComputeImageFlags(aURI, aIsMultiPart);
   // Select the type of image to create based on MIME type.
   if (aMimeType.EqualsLiteral(IMAGE_SVG_XML)) {
     return CreateVectorImage(aRequest, aStatusTracker, aMimeType,
                              aURI, imageFlags, aInnerWindowId);
   } else {
     return CreateRasterImage(aRequest, aStatusTracker, aMimeType,
                              aURI, imageFlags, aInnerWindowId);
   }
 }
 // Marks an image as having an error before returning it. Used with macros like
 // NS_ENSURE_SUCCESS, since we guarantee to always return an image even if an
 // error occurs, but callers need to be able to tell that this happened.
 template <typename T>
 static already_AddRefed<Image>
 BadImage(nsRefPtr<T>& image)
 {
   image->SetHasError();
   return image.forget();
 }
 /* static */ already_AddRefed<Image>
 ImageFactory::CreateAnonymousImage(const nsCString& aMimeType)
 {
   nsresult rv;
   nsRefPtr<RasterImage> newImage = new RasterImage();
   rv = newImage->Init(aMimeType.get(), Image::INIT_FLAG_NONE);
   NS_ENSURE_SUCCESS(rv, BadImage(newImage));
   return newImage.forget();
 }
 int32_t
 SaturateToInt32(int64_t val)
 {
   if (val > INT_MAX)
     return INT_MAX;
   if (val < INT_MIN)
     return INT_MIN;
   return static_cast<int32_t>(val);
 }
 uint32_t
 GetContentSize(nsIRequest* aRequest)
 {
   nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
   if (channel) {
     int64_t size;
     nsresult rv = channel->GetContentLength(&size);
     if (NS_SUCCEEDED(rv)) {
       return std::max(SaturateToInt32(size), 0);
     }
   }
   // Use the file size as a size hint for file channels.
   nsCOMPtr<nsIFileChannel> fileChannel(do_QueryInterface(aRequest));
   if (fileChannel) {
     nsCOMPtr<nsIFile> file;
     nsresult rv = fileChannel->GetFile(getter_AddRefs(file));
     if (NS_SUCCEEDED(rv)) {
       int64_t filesize;
       rv = file->GetFileSize(&filesize);
       if (NS_SUCCEEDED(rv)) {
         return std::max(SaturateToInt32(filesize), 0);
       }
     }
   }
   // Fallback - neither http nor file. We'll use dynamic allocation.
   return 0;
 }
 /* static */ already_AddRefed<Image>
 ImageFactory::CreateRasterImage(nsIRequest* aRequest,
                                 imgStatusTracker* aStatusTracker,
                                 const nsCString& aMimeType,
                                 ImageURL* aURI,
                                 uint32_t aImageFlags,
                                 uint32_t aInnerWindowId)
 {
   nsresult rv;
   nsRefPtr<RasterImage> newImage = new RasterImage(aStatusTracker, aURI);
   rv = newImage->Init(aMimeType.get(), aImageFlags);
   NS_ENSURE_SUCCESS(rv, BadImage(newImage));
   newImage->SetInnerWindowID(aInnerWindowId);
   uint32_t len = GetContentSize(aRequest);
   // Pass anything usable on so that the RasterImage can preallocate
   // its source buffer.
   if (len > 0) {
     uint32_t sizeHint = std::min<uint32_t>(len, 20000000); // Bound by something reasonable
     rv = newImage->SetSourceSizeHint(sizeHint);
     if (NS_FAILED(rv)) {
       // Flush memory, try to get some back, and try again.
       rv = nsMemory::HeapMinimize(true);
       nsresult rv2 = newImage->SetSourceSizeHint(sizeHint);
       // If we've still failed at this point, things are going downhill.
       if (NS_FAILED(rv) || NS_FAILED(rv2)) {
         NS_WARNING("About to hit OOM in imagelib!");
       }
     }
   }
   nsAutoCString ref;
   aURI->GetRef(ref);
   mozilla::net::nsMediaFragmentURIParser parser(ref);
   if (parser.HasResolution()) {
     newImage->SetRequestedResolution(parser.GetResolution());
   }
   if (parser.HasSampleSize()) {
       /* Get our principal */
       nsCOMPtr<nsIChannel> chan(do_QueryInterface(aRequest));
       nsCOMPtr<nsIPrincipal> principal;
       if (chan) {
         nsContentUtils::GetSecurityManager()->GetChannelPrincipal(chan,
                                                                   getter_AddRefs(principal));
       }
       if ((principal &&
            principal->GetAppStatus() == nsIPrincipal::APP_STATUS_CERTIFIED) ||
           gEnableMozSampleSize) {
         newImage->SetRequestedSampleSize(parser.GetSampleSize());
       }
   }
   return newImage.forget();
 }
 /* static */ already_AddRefed<Image>
 ImageFactory::CreateVectorImage(nsIRequest* aRequest,
                                 imgStatusTracker* aStatusTracker,
                                 const nsCString& aMimeType,
                                 ImageURL* aURI,
                                 uint32_t aImageFlags,
                                 uint32_t aInnerWindowId)
 {
   nsresult rv;
   nsRefPtr<VectorImage> newImage = new VectorImage(aStatusTracker, aURI);
   rv = newImage->Init(aMimeType.get(), aImageFlags);
   NS_ENSURE_SUCCESS(rv, BadImage(newImage));
   newImage->SetInnerWindowID(aInnerWindowId);
   rv = newImage->OnStartRequest(aRequest, nullptr);
   NS_ENSURE_SUCCESS(rv, BadImage(newImage));
   return newImage.forget();
 }
 } // namespace image
 } // namespace mozilla

The Tor Browser / annotate

image/src/ImageFactory.cpp@b8a032363ba2 (annotated)

image/src/ImageFactory.cpp