summaryrefslogtreecommitdiffstats
path: root/image/imgTools.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--image/imgTools.cpp649
1 files changed, 649 insertions, 0 deletions
diff --git a/image/imgTools.cpp b/image/imgTools.cpp
new file mode 100644
index 0000000000..864efc6f44
--- /dev/null
+++ b/image/imgTools.cpp
@@ -0,0 +1,649 @@
+/* -*- 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 "imgTools.h"
+
+#include "DecodePool.h"
+#include "gfxUtils.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/RefPtr.h"
+#include "nsCOMPtr.h"
+#include "mozilla/dom/Document.h"
+#include "nsError.h"
+#include "imgLoader.h"
+#include "imgICache.h"
+#include "imgIContainer.h"
+#include "imgIEncoder.h"
+#include "nsComponentManagerUtils.h"
+#include "nsNetUtil.h" // for NS_NewBufferedInputStream
+#include "nsStreamUtils.h"
+#include "nsStringStream.h"
+#include "nsContentUtils.h"
+#include "nsProxyRelease.h"
+#include "nsIStreamListener.h"
+#include "ImageFactory.h"
+#include "Image.h"
+#include "IProgressObserver.h"
+#include "ScriptedNotificationObserver.h"
+#include "imgIScriptedNotificationObserver.h"
+#include "gfxPlatform.h"
+#include "js/ArrayBuffer.h"
+#include "js/RootingAPI.h" // JS::{Handle,Rooted}
+#include "js/Value.h" // JS::Value
+#include "Orientation.h"
+
+using namespace mozilla::gfx;
+
+namespace mozilla {
+namespace image {
+
+namespace {
+
+static nsresult sniff_mimetype_callback(nsIInputStream* in, void* data,
+ const char* fromRawSegment,
+ uint32_t toOffset, uint32_t count,
+ uint32_t* writeCount) {
+ nsCString* mimeType = static_cast<nsCString*>(data);
+ MOZ_ASSERT(mimeType, "mimeType is null!");
+
+ if (count > 0) {
+ imgLoader::GetMimeTypeFromContent(fromRawSegment, count, *mimeType);
+ }
+
+ *writeCount = 0;
+ return NS_ERROR_FAILURE;
+}
+
+class ImageDecoderListener final : public nsIStreamListener,
+ public IProgressObserver,
+ public imgIContainer {
+ public:
+ NS_DECL_ISUPPORTS
+
+ ImageDecoderListener(nsIURI* aURI, imgIContainerCallback* aCallback,
+ imgINotificationObserver* aObserver)
+ : mURI(aURI),
+ mImage(nullptr),
+ mCallback(aCallback),
+ mObserver(aObserver) {
+ MOZ_ASSERT(NS_IsMainThread());
+ }
+
+ NS_IMETHOD
+ OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aInputStream,
+ uint64_t aOffset, uint32_t aCount) override {
+ if (!mImage) {
+ nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
+
+ nsCString mimeType;
+ channel->GetContentType(mimeType);
+
+ if (aInputStream) {
+ // Look at the first few bytes and see if we can tell what the data is
+ // from that since servers tend to lie. :(
+ uint32_t unused;
+ aInputStream->ReadSegments(sniff_mimetype_callback, &mimeType, aCount,
+ &unused);
+ }
+
+ RefPtr<ProgressTracker> tracker = new ProgressTracker();
+ if (mObserver) {
+ tracker->AddObserver(this);
+ }
+
+ mImage = ImageFactory::CreateImage(channel, tracker, mimeType, mURI,
+ /* aIsMultiPart */ false, 0);
+
+ if (mImage->HasError()) {
+ return NS_ERROR_FAILURE;
+ }
+ }
+
+ return mImage->OnImageDataAvailable(aRequest, aInputStream, aOffset,
+ aCount);
+ }
+
+ NS_IMETHOD
+ OnStartRequest(nsIRequest* aRequest) override { return NS_OK; }
+
+ NS_IMETHOD
+ OnStopRequest(nsIRequest* aRequest, nsresult aStatus) override {
+ // Encouter a fetch error, or no data could be fetched.
+ if (!mImage || NS_FAILED(aStatus)) {
+ mCallback->OnImageReady(nullptr, mImage ? aStatus : NS_ERROR_FAILURE);
+ return NS_OK;
+ }
+
+ mImage->OnImageDataComplete(aRequest, aStatus, true);
+ nsCOMPtr<imgIContainer> container = this;
+ mCallback->OnImageReady(container, aStatus);
+ return NS_OK;
+ }
+
+ virtual void Notify(int32_t aType,
+ const nsIntRect* aRect = nullptr) override {
+ if (mObserver) {
+ mObserver->Notify(nullptr, aType, aRect);
+ }
+ }
+
+ virtual void OnLoadComplete(bool aLastPart) override {}
+
+ // Other notifications are ignored.
+ virtual void SetHasImage() override {}
+ virtual bool NotificationsDeferred() const override { return false; }
+ virtual void MarkPendingNotify() override {}
+ virtual void ClearPendingNotify() override {}
+
+ // imgIContainer
+ NS_FORWARD_IMGICONTAINER(mImage->)
+
+ private:
+ virtual ~ImageDecoderListener() = default;
+
+ nsCOMPtr<nsIURI> mURI;
+ RefPtr<image::Image> mImage;
+ nsCOMPtr<imgIContainerCallback> mCallback;
+ nsCOMPtr<imgINotificationObserver> mObserver;
+};
+
+NS_IMPL_ISUPPORTS(ImageDecoderListener, nsIStreamListener, imgIContainer)
+
+class ImageDecoderHelper final : public Runnable,
+ public nsIInputStreamCallback {
+ public:
+ NS_DECL_ISUPPORTS_INHERITED
+
+ ImageDecoderHelper(already_AddRefed<image::Image> aImage,
+ already_AddRefed<nsIInputStream> aInputStream,
+ nsIEventTarget* aEventTarget,
+ imgIContainerCallback* aCallback,
+ nsIEventTarget* aCallbackEventTarget)
+ : Runnable("ImageDecoderHelper"),
+ mImage(std::move(aImage)),
+ mInputStream(std::move(aInputStream)),
+ mEventTarget(aEventTarget),
+ mCallback(aCallback),
+ mCallbackEventTarget(aCallbackEventTarget),
+ mStatus(NS_OK) {
+ MOZ_ASSERT(NS_IsMainThread());
+ }
+
+ NS_IMETHOD
+ Run() override {
+ // This runnable is dispatched on the Image thread when reading data, but
+ // at the end, it goes back to the main-thread in order to complete the
+ // operation.
+ if (NS_IsMainThread()) {
+ // Let the Image know we've sent all the data.
+ mImage->OnImageDataComplete(nullptr, mStatus, true);
+
+ RefPtr<ProgressTracker> tracker = mImage->GetProgressTracker();
+ tracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
+
+ nsCOMPtr<imgIContainer> container;
+ if (NS_SUCCEEDED(mStatus)) {
+ container = mImage;
+ }
+
+ mCallback->OnImageReady(container, mStatus);
+ return NS_OK;
+ }
+
+ uint64_t length;
+ nsresult rv = mInputStream->Available(&length);
+ if (rv == NS_BASE_STREAM_CLOSED) {
+ return OperationCompleted(NS_OK);
+ }
+
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return OperationCompleted(rv);
+ }
+
+ // Nothing else to read, but maybe we just need to wait.
+ if (length == 0) {
+ nsCOMPtr<nsIAsyncInputStream> asyncInputStream =
+ do_QueryInterface(mInputStream);
+ if (asyncInputStream) {
+ rv = asyncInputStream->AsyncWait(this, 0, 0, mEventTarget);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return OperationCompleted(rv);
+ }
+ return NS_OK;
+ }
+
+ // We really have nothing else to read.
+ if (length == 0) {
+ return OperationCompleted(NS_OK);
+ }
+ }
+
+ // Send the source data to the Image.
+ rv = mImage->OnImageDataAvailable(nullptr, mInputStream, 0,
+ uint32_t(length));
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return OperationCompleted(rv);
+ }
+
+ rv = mEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return OperationCompleted(rv);
+ }
+
+ return NS_OK;
+ }
+
+ NS_IMETHOD
+ OnInputStreamReady(nsIAsyncInputStream* aAsyncInputStream) override {
+ MOZ_ASSERT(!NS_IsMainThread());
+ return Run();
+ }
+
+ nsresult OperationCompleted(nsresult aStatus) {
+ MOZ_ASSERT(!NS_IsMainThread());
+
+ mStatus = aStatus;
+ mCallbackEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
+ return NS_OK;
+ }
+
+ private:
+ ~ImageDecoderHelper() {
+ SurfaceCache::ReleaseImageOnMainThread(mImage.forget());
+ NS_ReleaseOnMainThread("ImageDecoderHelper::mCallback", mCallback.forget());
+ }
+
+ RefPtr<image::Image> mImage;
+
+ nsCOMPtr<nsIInputStream> mInputStream;
+ nsCOMPtr<nsIEventTarget> mEventTarget;
+ nsCOMPtr<imgIContainerCallback> mCallback;
+ nsCOMPtr<nsIEventTarget> mCallbackEventTarget;
+
+ nsresult mStatus;
+};
+
+NS_IMPL_ISUPPORTS_INHERITED(ImageDecoderHelper, Runnable,
+ nsIInputStreamCallback)
+
+} // namespace
+
+/* ========== imgITools implementation ========== */
+
+NS_IMPL_ISUPPORTS(imgTools, imgITools)
+
+imgTools::imgTools() { /* member initializers and constructor code */
+}
+
+imgTools::~imgTools() { /* destructor code */
+}
+
+NS_IMETHODIMP
+imgTools::DecodeImageFromArrayBuffer(JS::Handle<JS::Value> aArrayBuffer,
+ const nsACString& aMimeType,
+ JSContext* aCx,
+ imgIContainer** aContainer) {
+ if (!aArrayBuffer.isObject()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ JS::Rooted<JSObject*> obj(aCx,
+ JS::UnwrapArrayBuffer(&aArrayBuffer.toObject()));
+ if (!obj) {
+ return NS_ERROR_FAILURE;
+ }
+
+ uint8_t* bufferData = nullptr;
+ size_t bufferLength = 0;
+ bool isSharedMemory = false;
+
+ JS::GetArrayBufferLengthAndData(obj, &bufferLength, &isSharedMemory,
+ &bufferData);
+
+ // Throw for large ArrayBuffers to prevent truncation.
+ if (bufferLength > INT32_MAX) {
+ return NS_ERROR_ILLEGAL_VALUE;
+ }
+
+ return DecodeImageFromBuffer((char*)bufferData, bufferLength, aMimeType,
+ aContainer);
+}
+
+NS_IMETHODIMP
+imgTools::DecodeImageFromBuffer(const char* aBuffer, uint32_t aSize,
+ const nsACString& aMimeType,
+ imgIContainer** aContainer) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ NS_ENSURE_ARG_POINTER(aBuffer);
+
+ // Create a new image container to hold the decoded data.
+ nsAutoCString mimeType(aMimeType);
+ RefPtr<image::Image> image =
+ ImageFactory::CreateAnonymousImage(mimeType, aSize);
+ RefPtr<ProgressTracker> tracker = image->GetProgressTracker();
+
+ if (image->HasError()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // Let's create a temporary inputStream.
+ nsCOMPtr<nsIInputStream> stream;
+ nsresult rv = NS_NewByteInputStream(
+ getter_AddRefs(stream), Span(aBuffer, aSize), NS_ASSIGNMENT_DEPEND);
+ NS_ENSURE_SUCCESS(rv, rv);
+ MOZ_ASSERT(stream);
+ MOZ_ASSERT(NS_InputStreamIsBuffered(stream));
+
+ rv = image->OnImageDataAvailable(nullptr, stream, 0, aSize);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Let the Image know we've sent all the data.
+ rv = image->OnImageDataComplete(nullptr, NS_OK, true);
+ tracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // All done.
+ image.forget(aContainer);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgTools::DecodeImageFromChannelAsync(nsIURI* aURI, nsIChannel* aChannel,
+ imgIContainerCallback* aCallback,
+ imgINotificationObserver* aObserver) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ NS_ENSURE_ARG_POINTER(aURI);
+ NS_ENSURE_ARG_POINTER(aChannel);
+ NS_ENSURE_ARG_POINTER(aCallback);
+
+ RefPtr<ImageDecoderListener> listener =
+ new ImageDecoderListener(aURI, aCallback, aObserver);
+
+ return aChannel->AsyncOpen(listener);
+}
+
+NS_IMETHODIMP
+imgTools::DecodeImageAsync(nsIInputStream* aInStr, const nsACString& aMimeType,
+ imgIContainerCallback* aCallback,
+ nsIEventTarget* aEventTarget) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ NS_ENSURE_ARG_POINTER(aInStr);
+ NS_ENSURE_ARG_POINTER(aCallback);
+ NS_ENSURE_ARG_POINTER(aEventTarget);
+
+ nsresult rv;
+
+ // Let's continuing the reading on a separate thread.
+ DecodePool* decodePool = DecodePool::Singleton();
+ MOZ_ASSERT(decodePool);
+
+ RefPtr<nsIEventTarget> target = decodePool->GetIOEventTarget();
+ NS_ENSURE_TRUE(target, NS_ERROR_FAILURE);
+
+ // Prepare the input stream.
+ nsCOMPtr<nsIInputStream> stream = aInStr;
+ if (!NS_InputStreamIsBuffered(aInStr)) {
+ nsCOMPtr<nsIInputStream> bufStream;
+ rv = NS_NewBufferedInputStream(getter_AddRefs(bufStream), stream.forget(),
+ 1024);
+ NS_ENSURE_SUCCESS(rv, rv);
+ stream = std::move(bufStream);
+ }
+
+ // Create a new image container to hold the decoded data.
+ nsAutoCString mimeType(aMimeType);
+ RefPtr<image::Image> image = ImageFactory::CreateAnonymousImage(mimeType, 0);
+
+ // Already an error?
+ if (image->HasError()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<ImageDecoderHelper> helper = new ImageDecoderHelper(
+ image.forget(), stream.forget(), target, aCallback, aEventTarget);
+ rv = target->Dispatch(helper.forget(), NS_DISPATCH_NORMAL);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return NS_OK;
+}
+
+/**
+ * This takes a DataSourceSurface rather than a SourceSurface because some
+ * of the callers have a DataSourceSurface and we don't want to call
+ * GetDataSurface on such surfaces since that may incur a conversion to
+ * SurfaceType::DATA which we don't need.
+ */
+static nsresult EncodeImageData(DataSourceSurface* aDataSurface,
+ DataSourceSurface::ScopedMap& aMap,
+ const nsACString& aMimeType,
+ const nsAString& aOutputOptions,
+ nsIInputStream** aStream) {
+ MOZ_ASSERT(aDataSurface->GetFormat() == SurfaceFormat::B8G8R8A8 ||
+ aDataSurface->GetFormat() == SurfaceFormat::B8G8R8X8,
+ "We're assuming B8G8R8A8/X8");
+
+ // Get an image encoder for the media type
+ nsAutoCString encoderCID("@mozilla.org/image/encoder;2?type="_ns + aMimeType);
+
+ nsCOMPtr<imgIEncoder> encoder = do_CreateInstance(encoderCID.get());
+ if (!encoder) {
+ return NS_IMAGELIB_ERROR_NO_ENCODER;
+ }
+
+ IntSize size = aDataSurface->GetSize();
+ uint32_t dataLength = aMap.GetStride() * size.height;
+
+ // Encode the bitmap
+ nsresult rv = encoder->InitFromData(
+ aMap.GetData(), dataLength, size.width, size.height, aMap.GetStride(),
+ imgIEncoder::INPUT_FORMAT_HOSTARGB, aOutputOptions);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ encoder.forget(aStream);
+ return NS_OK;
+}
+
+static nsresult EncodeImageData(DataSourceSurface* aDataSurface,
+ const nsACString& aMimeType,
+ const nsAString& aOutputOptions,
+ nsIInputStream** aStream) {
+ DataSourceSurface::ScopedMap map(aDataSurface, DataSourceSurface::READ);
+ if (!map.IsMapped()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return EncodeImageData(aDataSurface, map, aMimeType, aOutputOptions, aStream);
+}
+
+NS_IMETHODIMP
+imgTools::EncodeImage(imgIContainer* aContainer, const nsACString& aMimeType,
+ const nsAString& aOutputOptions,
+ nsIInputStream** aStream) {
+ // Use frame 0 from the image container.
+ RefPtr<SourceSurface> frame = aContainer->GetFrame(
+ imgIContainer::FRAME_FIRST,
+ imgIContainer::FLAG_SYNC_DECODE | imgIContainer::FLAG_ASYNC_NOTIFY);
+ NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
+
+ RefPtr<DataSourceSurface> dataSurface;
+
+ if (frame->GetFormat() == SurfaceFormat::B8G8R8A8 ||
+ frame->GetFormat() == SurfaceFormat::B8G8R8X8) {
+ dataSurface = frame->GetDataSurface();
+ } else {
+ // Convert format to SurfaceFormat::B8G8R8A8
+ dataSurface = gfxUtils::CopySurfaceToDataSourceSurfaceWithFormat(
+ frame, SurfaceFormat::B8G8R8A8);
+ }
+
+ NS_ENSURE_TRUE(dataSurface, NS_ERROR_FAILURE);
+
+ return EncodeImageData(dataSurface, aMimeType, aOutputOptions, aStream);
+}
+
+NS_IMETHODIMP
+imgTools::EncodeScaledImage(imgIContainer* aContainer,
+ const nsACString& aMimeType, int32_t aScaledWidth,
+ int32_t aScaledHeight,
+ const nsAString& aOutputOptions,
+ nsIInputStream** aStream) {
+ NS_ENSURE_ARG(aScaledWidth >= 0 && aScaledHeight >= 0);
+
+ // If no scaled size is specified, we'll just encode the image at its
+ // original size (no scaling).
+ if (aScaledWidth == 0 && aScaledHeight == 0) {
+ return EncodeImage(aContainer, aMimeType, aOutputOptions, aStream);
+ }
+
+ // Retrieve the image's size.
+ int32_t imageWidth = 0;
+ int32_t imageHeight = 0;
+ aContainer->GetWidth(&imageWidth);
+ aContainer->GetHeight(&imageHeight);
+
+ // If the given width or height is zero we'll replace it with the image's
+ // original dimensions.
+ IntSize scaledSize(aScaledWidth == 0 ? imageWidth : aScaledWidth,
+ aScaledHeight == 0 ? imageHeight : aScaledHeight);
+
+ // Use frame 0 from the image container.
+ RefPtr<SourceSurface> frame = aContainer->GetFrameAtSize(
+ scaledSize, imgIContainer::FRAME_FIRST,
+ imgIContainer::FLAG_HIGH_QUALITY_SCALING |
+ imgIContainer::FLAG_SYNC_DECODE | imgIContainer::FLAG_ASYNC_NOTIFY);
+ NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
+
+ // If the given surface is the right size/format, we can encode it directly.
+ if (scaledSize == frame->GetSize() &&
+ (frame->GetFormat() == SurfaceFormat::B8G8R8A8 ||
+ frame->GetFormat() == SurfaceFormat::B8G8R8X8)) {
+ RefPtr<DataSourceSurface> dataSurface = frame->GetDataSurface();
+ if (dataSurface) {
+ return EncodeImageData(dataSurface, aMimeType, aOutputOptions, aStream);
+ }
+ }
+
+ // Otherwise we need to scale it using a draw target.
+ RefPtr<DataSourceSurface> dataSurface =
+ Factory::CreateDataSourceSurface(scaledSize, SurfaceFormat::B8G8R8A8);
+ if (NS_WARN_IF(!dataSurface)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ DataSourceSurface::ScopedMap map(dataSurface, DataSourceSurface::READ_WRITE);
+ if (!map.IsMapped()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<DrawTarget> dt = Factory::CreateDrawTargetForData(
+ BackendType::SKIA, map.GetData(), dataSurface->GetSize(), map.GetStride(),
+ SurfaceFormat::B8G8R8A8);
+ if (!dt) {
+ gfxWarning() << "imgTools::EncodeImage failed in CreateDrawTargetForData";
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ IntSize frameSize = frame->GetSize();
+ dt->DrawSurface(frame, Rect(0, 0, scaledSize.width, scaledSize.height),
+ Rect(0, 0, frameSize.width, frameSize.height),
+ DrawSurfaceOptions(),
+ DrawOptions(1.0f, CompositionOp::OP_SOURCE));
+
+ return EncodeImageData(dataSurface, map, aMimeType, aOutputOptions, aStream);
+}
+
+NS_IMETHODIMP
+imgTools::EncodeCroppedImage(imgIContainer* aContainer,
+ const nsACString& aMimeType, int32_t aOffsetX,
+ int32_t aOffsetY, int32_t aWidth, int32_t aHeight,
+ const nsAString& aOutputOptions,
+ nsIInputStream** aStream) {
+ NS_ENSURE_ARG(aOffsetX >= 0 && aOffsetY >= 0 && aWidth >= 0 && aHeight >= 0);
+
+ // Offsets must be zero when no width and height are given or else we're out
+ // of bounds.
+ NS_ENSURE_ARG(aWidth + aHeight > 0 || aOffsetX + aOffsetY == 0);
+
+ // If no size is specified then we'll preserve the image's original dimensions
+ // and don't need to crop.
+ if (aWidth == 0 && aHeight == 0) {
+ return EncodeImage(aContainer, aMimeType, aOutputOptions, aStream);
+ }
+
+ // Use frame 0 from the image container.
+ RefPtr<SourceSurface> frame = aContainer->GetFrame(
+ imgIContainer::FRAME_FIRST,
+ imgIContainer::FLAG_SYNC_DECODE | imgIContainer::FLAG_ASYNC_NOTIFY);
+ NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
+
+ int32_t frameWidth = frame->GetSize().width;
+ int32_t frameHeight = frame->GetSize().height;
+
+ // If the given width or height is zero we'll replace it with the image's
+ // original dimensions.
+ if (aWidth == 0) {
+ aWidth = frameWidth;
+ } else if (aHeight == 0) {
+ aHeight = frameHeight;
+ }
+
+ // Check that the given crop rectangle is within image bounds.
+ NS_ENSURE_ARG(frameWidth >= aOffsetX + aWidth &&
+ frameHeight >= aOffsetY + aHeight);
+
+ RefPtr<DataSourceSurface> dataSurface = Factory::CreateDataSourceSurface(
+ IntSize(aWidth, aHeight), SurfaceFormat::B8G8R8A8,
+ /* aZero = */ true);
+ if (NS_WARN_IF(!dataSurface)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ DataSourceSurface::ScopedMap map(dataSurface, DataSourceSurface::READ_WRITE);
+ if (!map.IsMapped()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<DrawTarget> dt = Factory::CreateDrawTargetForData(
+ BackendType::SKIA, map.GetData(), dataSurface->GetSize(), map.GetStride(),
+ SurfaceFormat::B8G8R8A8);
+ if (!dt) {
+ gfxWarning()
+ << "imgTools::EncodeCroppedImage failed in CreateDrawTargetForData";
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ dt->CopySurface(frame, IntRect(aOffsetX, aOffsetY, aWidth, aHeight),
+ IntPoint(0, 0));
+
+ return EncodeImageData(dataSurface, map, aMimeType, aOutputOptions, aStream);
+}
+
+NS_IMETHODIMP
+imgTools::CreateScriptedObserver(imgIScriptedNotificationObserver* aInner,
+ imgINotificationObserver** aObserver) {
+ NS_ADDREF(*aObserver = new ScriptedNotificationObserver(aInner));
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgTools::GetImgLoaderForDocument(dom::Document* aDoc, imgILoader** aLoader) {
+ NS_IF_ADDREF(*aLoader = nsContentUtils::GetImgLoaderForDocument(aDoc));
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgTools::GetImgCacheForDocument(dom::Document* aDoc, imgICache** aCache) {
+ nsCOMPtr<imgILoader> loader;
+ nsresult rv = GetImgLoaderForDocument(aDoc, getter_AddRefs(loader));
+ NS_ENSURE_SUCCESS(rv, rv);
+ return CallQueryInterface(loader, aCache);
+}
+
+} // namespace image
+} // namespace mozilla