Source code
Revision control
Copy as Markdown
Other Tools
/* 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
#include "gtest/gtest.h"
#include "Common.h"
#include "imgIContainer.h"
#include "ImageOps.h"
#include "mozilla/gfx/2D.h"
#include "nsComponentManagerUtils.h"
#include "nsCOMPtr.h"
#include "nsIInputStream.h"
#include "nsIRunnable.h"
#include "nsIThread.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsThreadUtils.h"
using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::image;
class DecodeToSurfaceRunnable : public Runnable {
public:
DecodeToSurfaceRunnable(RefPtr<SourceSurface>& aSurface,
nsIInputStream* aInputStream,
ImageOps::ImageBuffer* aImageBuffer,
const ImageTestCase& aTestCase)
: mozilla::Runnable("DecodeToSurfaceRunnable"),
mSurface(aSurface),
mInputStream(aInputStream),
mImageBuffer(aImageBuffer),
mTestCase(aTestCase) {}
NS_IMETHOD Run() override {
Go();
return NS_OK;
}
void Go() {
Maybe<IntSize> outputSize;
if (mTestCase.mOutputSize != mTestCase.mSize) {
outputSize.emplace(mTestCase.mOutputSize);
}
uint32_t flags = FromSurfaceFlags(mTestCase.mSurfaceFlags);
if (mImageBuffer) {
mSurface = ImageOps::DecodeToSurface(
mImageBuffer, nsDependentCString(mTestCase.mMimeType), flags,
outputSize);
} else {
mSurface = ImageOps::DecodeToSurface(
mInputStream.forget(), nsDependentCString(mTestCase.mMimeType), flags,
outputSize);
}
ASSERT_TRUE(mSurface != nullptr);
EXPECT_TRUE(mSurface->IsDataSourceSurface());
EXPECT_TRUE(mSurface->GetFormat() == SurfaceFormat::OS_RGBX ||
mSurface->GetFormat() == SurfaceFormat::OS_RGBA);
if (outputSize) {
EXPECT_EQ(*outputSize, mSurface->GetSize());
} else {
EXPECT_EQ(mTestCase.mSize, mSurface->GetSize());
}
EXPECT_TRUE(IsSolidColor(mSurface, mTestCase.Color(), mTestCase.Fuzz()));
}
private:
RefPtr<SourceSurface>& mSurface;
nsCOMPtr<nsIInputStream> mInputStream;
RefPtr<ImageOps::ImageBuffer> mImageBuffer;
ImageTestCase mTestCase;
};
static void RunDecodeToSurface(const ImageTestCase& aTestCase,
ImageOps::ImageBuffer* aImageBuffer = nullptr) {
nsCOMPtr<nsIInputStream> inputStream;
if (!aImageBuffer) {
inputStream = LoadFile(aTestCase.mPath);
ASSERT_TRUE(inputStream != nullptr);
}
nsCOMPtr<nsIThread> thread;
nsresult rv =
NS_NewNamedThread("DecodeToSurface", getter_AddRefs(thread), nullptr);
ASSERT_NS_SUCCEEDED(rv);
// We run the DecodeToSurface tests off-main-thread to ensure that
// DecodeToSurface doesn't require any main-thread-only code.
RefPtr<SourceSurface> surface;
nsCOMPtr<nsIRunnable> runnable = new DecodeToSurfaceRunnable(
surface, inputStream, aImageBuffer, aTestCase);
NS_DispatchAndSpinEventLoopUntilComplete("RunDecodeToSurface"_ns, thread,
do_AddRef(runnable));
thread->Shutdown();
// Explicitly release the SourceSurface on the main thread.
surface = nullptr;
}
class ImageDecodeToSurface : public ::testing::Test {
protected:
AutoInitializeImageLib mInit;
};
TEST_F(ImageDecodeToSurface, PNG) { RunDecodeToSurface(GreenPNGTestCase()); }
TEST_F(ImageDecodeToSurface, GIF) { RunDecodeToSurface(GreenGIFTestCase()); }
TEST_F(ImageDecodeToSurface, JPG) { RunDecodeToSurface(GreenJPGTestCase()); }
TEST_F(ImageDecodeToSurface, BMP) { RunDecodeToSurface(GreenBMPTestCase()); }
TEST_F(ImageDecodeToSurface, ICO) { RunDecodeToSurface(GreenICOTestCase()); }
TEST_F(ImageDecodeToSurface, Icon) { RunDecodeToSurface(GreenIconTestCase()); }
TEST_F(ImageDecodeToSurface, WebP) { RunDecodeToSurface(GreenWebPTestCase()); }
TEST_F(ImageDecodeToSurface, AnimatedGIF) {
RunDecodeToSurface(GreenFirstFrameAnimatedGIFTestCase());
}
TEST_F(ImageDecodeToSurface, AnimatedPNG) {
RunDecodeToSurface(GreenFirstFrameAnimatedPNGTestCase());
}
TEST_F(ImageDecodeToSurface, Corrupt) {
ImageTestCase testCase = CorruptTestCase();
nsCOMPtr<nsIInputStream> inputStream = LoadFile(testCase.mPath);
ASSERT_TRUE(inputStream != nullptr);
RefPtr<SourceSurface> surface = ImageOps::DecodeToSurface(
inputStream.forget(), nsDependentCString(testCase.mMimeType),
imgIContainer::DECODE_FLAGS_DEFAULT);
EXPECT_TRUE(surface == nullptr);
}
TEST_F(ImageDecodeToSurface, ICOMultipleSizes) {
ImageTestCase testCase = GreenMultipleSizesICOTestCase();
nsCOMPtr<nsIInputStream> inputStream = LoadFile(testCase.mPath);
ASSERT_TRUE(inputStream != nullptr);
RefPtr<ImageOps::ImageBuffer> buffer =
ImageOps::CreateImageBuffer(inputStream.forget());
ASSERT_TRUE(buffer != nullptr);
ImageMetadata metadata;
nsresult rv = ImageOps::DecodeMetadata(
buffer, nsDependentCString(testCase.mMimeType), metadata);
EXPECT_NS_SUCCEEDED(rv);
ASSERT_TRUE(metadata.HasSize());
EXPECT_EQ(testCase.mSize, metadata.GetSize().ToUnknownSize());
const nsTArray<OrientedIntSize>& nativeSizes = metadata.GetNativeSizes();
ASSERT_EQ(6u, nativeSizes.Length());
OrientedIntSize expectedSizes[] = {
OrientedIntSize(16, 16), OrientedIntSize(32, 32),
OrientedIntSize(64, 64), OrientedIntSize(128, 128),
OrientedIntSize(256, 256), OrientedIntSize(256, 128),
};
for (int i = 0; i < 6; ++i) {
EXPECT_EQ(expectedSizes[i], nativeSizes[i]);
// Request decoding at native size
testCase.mOutputSize = nativeSizes[i].ToUnknownSize();
RunDecodeToSurface(testCase, buffer);
}
}