/* -*- 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 "ImageFactory.h" #include <algorithm> #include "mozilla/Likely.h" #include "nsIHttpChannel.h" #include "nsIFileChannel.h" #include "nsIFile.h" #include "nsMimeTypes.h" #include "nsIRequest.h" #include "MultipartImage.h" #include "RasterImage.h" #include "VectorImage.h" #include "Image.h" #include "nsMediaFragmentURIParser.h" #include "nsContentUtils.h" #include "nsIScriptSecurityManager.h" #include "gfxPrefs.h" namespace mozilla { namespace image { /*static*/ void ImageFactory::Initialize() { } static uint32_t ComputeImageFlags(ImageURL* uri, const nsCString& aMimeType, bool isMultiPart) { nsresult rv; // We default to the static globals. bool isDiscardable = gfxPrefs::ImageMemDiscardable(); bool doDecodeImmediately = gfxPrefs::ImageDecodeImmediatelyEnabled(); // We want UI to be as snappy as possible and not to flicker. Disable // discarding for chrome URLS. bool isChrome = false; rv = uri->SchemeIs("chrome", &isChrome); if (NS_SUCCEEDED(rv) && isChrome) { isDiscardable = false; } // We don't want resources like the "loading" icon to be discardable either. bool isResource = false; rv = uri->SchemeIs("resource", &isResource); if (NS_SUCCEEDED(rv) && isResource) { isDiscardable = false; } // For multipart/x-mixed-replace, we basically want a direct channel to the // decoder. Disable everything for this case. if (isMultiPart) { isDiscardable = false; } // We have all the information we need. uint32_t imageFlags = Image::INIT_FLAG_NONE; if (isDiscardable) { imageFlags |= Image::INIT_FLAG_DISCARDABLE; } if (doDecodeImmediately) { imageFlags |= Image::INIT_FLAG_DECODE_IMMEDIATELY; } if (isMultiPart) { imageFlags |= Image::INIT_FLAG_TRANSIENT; } return imageFlags; } /* static */ already_AddRefed<Image> ImageFactory::CreateImage(nsIRequest* aRequest, ProgressTracker* aProgressTracker, const nsCString& aMimeType, ImageURL* aURI, bool aIsMultiPart, uint32_t aInnerWindowId) { MOZ_ASSERT(gfxPrefs::SingletonExists(), "Pref observers should have been initialized already"); // Compute the image's initialization flags. uint32_t imageFlags = ComputeImageFlags(aURI, aMimeType, aIsMultiPart); // Select the type of image to create based on MIME type. if (aMimeType.EqualsLiteral(IMAGE_SVG_XML)) { return CreateVectorImage(aRequest, aProgressTracker, aMimeType, aURI, imageFlags, aInnerWindowId); } else { return CreateRasterImage(aRequest, aProgressTracker, aMimeType, aURI, imageFlags, aInnerWindowId); } } // Marks an image as having an error before returning it. template <typename T> static already_AddRefed<Image> BadImage(const char* aMessage, RefPtr<T>& aImage) { aImage->SetHasError(); return aImage.forget(); } /* static */ already_AddRefed<Image> ImageFactory::CreateAnonymousImage(const nsCString& aMimeType) { nsresult rv; RefPtr<RasterImage> newImage = new RasterImage(); RefPtr<ProgressTracker> newTracker = new ProgressTracker(); newTracker->SetImage(newImage); newImage->SetProgressTracker(newTracker); rv = newImage->Init(aMimeType.get(), Image::INIT_FLAG_SYNC_LOAD); if (NS_FAILED(rv)) { return BadImage("RasterImage::Init failed", newImage); } return newImage.forget(); } /* static */ already_AddRefed<MultipartImage> ImageFactory::CreateMultipartImage(Image* aFirstPart, ProgressTracker* aProgressTracker) { MOZ_ASSERT(aFirstPart); MOZ_ASSERT(aProgressTracker); RefPtr<MultipartImage> newImage = new MultipartImage(aFirstPart); aProgressTracker->SetImage(newImage); newImage->SetProgressTracker(aProgressTracker); newImage->Init(); 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, ProgressTracker* aProgressTracker, const nsCString& aMimeType, ImageURL* aURI, uint32_t aImageFlags, uint32_t aInnerWindowId) { MOZ_ASSERT(aProgressTracker); nsresult rv; RefPtr<RasterImage> newImage = new RasterImage(aURI); aProgressTracker->SetImage(newImage); newImage->SetProgressTracker(aProgressTracker); nsAutoCString ref; aURI->GetRef(ref); net::nsMediaFragmentURIParser parser(ref); if (parser.HasSampleSize()) { /* Get our principal */ nsCOMPtr<nsIChannel> chan(do_QueryInterface(aRequest)); nsCOMPtr<nsIPrincipal> principal; if (chan) { nsContentUtils::GetSecurityManager() ->GetChannelResultPrincipal(chan, getter_AddRefs(principal)); } if ((principal && principal->GetAppStatus() == nsIPrincipal::APP_STATUS_CERTIFIED) || gfxPrefs::ImageMozSampleSizeEnabled()) { newImage->SetRequestedSampleSize(parser.GetSampleSize()); } } rv = newImage->Init(aMimeType.get(), aImageFlags); if (NS_FAILED(rv)) { return BadImage("RasterImage::Init failed", 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) { // Bound by something reasonable uint32_t sizeHint = std::min<uint32_t>(len, 20000000); 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!"); } } } return newImage.forget(); } /* static */ already_AddRefed<Image> ImageFactory::CreateVectorImage(nsIRequest* aRequest, ProgressTracker* aProgressTracker, const nsCString& aMimeType, ImageURL* aURI, uint32_t aImageFlags, uint32_t aInnerWindowId) { MOZ_ASSERT(aProgressTracker); nsresult rv; RefPtr<VectorImage> newImage = new VectorImage(aURI); aProgressTracker->SetImage(newImage); newImage->SetProgressTracker(aProgressTracker); rv = newImage->Init(aMimeType.get(), aImageFlags); if (NS_FAILED(rv)) { return BadImage("VectorImage::Init failed", newImage); } newImage->SetInnerWindowID(aInnerWindowId); rv = newImage->OnStartRequest(aRequest, nullptr); if (NS_FAILED(rv)) { return BadImage("VectorImage::OnStartRequest failed", newImage); } return newImage.forget(); } } // namespace image } // namespace mozilla