diff -r 000000000000 -r 6474c204b198 image/src/ImageFactory.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/image/src/ImageFactory.cpp Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,287 @@ +/* -*- 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 + +#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 +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 +static already_AddRefed +BadImage(nsRefPtr& image) +{ + image->SetHasError(); + return image.forget(); +} + +/* static */ already_AddRefed +ImageFactory::CreateAnonymousImage(const nsCString& aMimeType) +{ + nsresult rv; + + nsRefPtr 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(val); +} + +uint32_t +GetContentSize(nsIRequest* aRequest) +{ + nsCOMPtr 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 fileChannel(do_QueryInterface(aRequest)); + if (fileChannel) { + nsCOMPtr 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 +ImageFactory::CreateRasterImage(nsIRequest* aRequest, + imgStatusTracker* aStatusTracker, + const nsCString& aMimeType, + ImageURL* aURI, + uint32_t aImageFlags, + uint32_t aInnerWindowId) +{ + nsresult rv; + + nsRefPtr 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(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 chan(do_QueryInterface(aRequest)); + nsCOMPtr 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 +ImageFactory::CreateVectorImage(nsIRequest* aRequest, + imgStatusTracker* aStatusTracker, + const nsCString& aMimeType, + ImageURL* aURI, + uint32_t aImageFlags, + uint32_t aInnerWindowId) +{ + nsresult rv; + + nsRefPtr 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