Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-02-22 02:09:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1294490 - Part 6. Implement WebP gtests. r=tnikkel

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D8119
This commit is contained in:
Andrew Osmond 2018-10-31 14:16:17 -04:00
parent d87a27c07f
commit 0ccd2cb7f6
10 changed files with 327 additions and 236 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
image/test/gtest/Common.cpp
View File

@ -38,7 +38,12 @@ AutoInitializeImageLib::AutoInitializeImageLib()
sImageLibInitialized = true;
// Force sRGB to be consistent with reftests.
Preferences::SetBool("gfx.color_management.force_srgb", true);
nsresult rv = Preferences::SetBool("gfx.color_management.force_srgb", true);
EXPECT_TRUE(rv == NS_OK);
// Ensure WebP is enabled to run decoder tests.
rv = Preferences::SetBool("image.webp.enabled", true);
EXPECT_TRUE(rv == NS_OK);
// Ensure that ImageLib services are initialized.
nsCOMPtr<imgITools> imgTools = do_CreateInstance("@mozilla.org/image/tools;1");
@ -551,6 +556,16 @@ ImageTestCase GreenIconTestCase()
TEST_CASE_IS_TRANSPARENT);
}
ImageTestCase GreenWebPTestCase()
{
return ImageTestCase("green.webp", "image/webp", IntSize(100, 100));
}
ImageTestCase GreenWebPIccSrgbTestCase()
{
return ImageTestCase("green.icc_srgb.webp", "image/webp", IntSize(100, 100));
}
ImageTestCase GreenFirstFrameAnimatedGIFTestCase()
{
return ImageTestCase("first-frame-green.gif", "image/gif", IntSize(100, 100),
@ -563,6 +578,12 @@ ImageTestCase GreenFirstFrameAnimatedPNGTestCase()
TEST_CASE_IS_TRANSPARENT | TEST_CASE_IS_ANIMATED);
}
ImageTestCase GreenFirstFrameAnimatedWebPTestCase()
{
return ImageTestCase("first-frame-green.webp", "image/webp", IntSize(100, 100),
TEST_CASE_IS_ANIMATED);
}
ImageTestCase CorruptTestCase()
{
return ImageTestCase("corrupt.jpg", "image/jpeg", IntSize(100, 100),
@ -699,6 +720,12 @@ ImageTestCase DownscaledIconTestCase()
IntSize(20, 20), TEST_CASE_IS_TRANSPARENT);
}
ImageTestCase DownscaledWebPTestCase()
{
return ImageTestCase("downscaled.webp", "image/webp", IntSize(100, 100),
IntSize(20, 20));
}
ImageTestCase DownscaledTransparentICOWithANDMaskTestCase()
{
// This test case is an ICO with AND mask transparency. We want to ensure that

5
image/test/gtest/Common.h
View File

@ -433,9 +433,13 @@ ImageTestCase GreenJPGTestCase();
ImageTestCase GreenBMPTestCase();
ImageTestCase GreenICOTestCase();
ImageTestCase GreenIconTestCase();
ImageTestCase GreenWebPTestCase();
ImageTestCase GreenWebPIccSrgbTestCase();
ImageTestCase GreenFirstFrameAnimatedGIFTestCase();
ImageTestCase GreenFirstFrameAnimatedPNGTestCase();
ImageTestCase GreenFirstFrameAnimatedWebPTestCase();
ImageTestCase CorruptTestCase();
ImageTestCase CorruptBMPWithTruncatedHeader();
@ -460,6 +464,7 @@ ImageTestCase DownscaledJPGTestCase();
ImageTestCase DownscaledBMPTestCase();
ImageTestCase DownscaledICOTestCase();
ImageTestCase DownscaledIconTestCase();
ImageTestCase DownscaledWebPTestCase();
ImageTestCase DownscaledTransparentICOWithANDMaskTestCase();
ImageTestCase TruncatedSmallGIFTestCase();

1
image/test/gtest/TestDecodeToSurface.cpp
View File

@ -125,6 +125,7 @@ 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)
{

523
image/test/gtest/TestDecoders.cpp
View File

@ -329,6 +329,247 @@ CheckAnimationDecoderSingleChunk(const ImageTestCase& aTestCase)
});
}
static void
CheckDecoderFrameFirst(const ImageTestCase& aTestCase)
{
// Verify that we can decode this test case and retrieve the first frame using
// imgIContainer::FRAME_FIRST. This ensures that we correctly trigger a
// single-frame decode rather than an animated decode when
// imgIContainer::FRAME_FIRST is requested.
// Create an image.
RefPtr<Image> image =
ImageFactory::CreateAnonymousImage(nsDependentCString(aTestCase.mMimeType));
ASSERT_TRUE(!image->HasError());
nsCOMPtr<nsIInputStream> inputStream = LoadFile(aTestCase.mPath);
ASSERT_TRUE(inputStream);
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
// Write the data into the image.
rv = image->OnImageDataAvailable(nullptr, nullptr, inputStream, 0,
static_cast<uint32_t>(length));
ASSERT_TRUE(NS_SUCCEEDED(rv));
// Let the image know we've sent all the data.
rv = image->OnImageDataComplete(nullptr, nullptr, NS_OK, true);
ASSERT_TRUE(NS_SUCCEEDED(rv));
RefPtr<ProgressTracker> tracker = image->GetProgressTracker();
tracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
// Lock the image so its surfaces don't disappear during the test.
image->LockImage();
auto unlock = mozilla::MakeScopeExit([&] {
image->UnlockImage();
});
// Use GetFrame() to force a sync decode of the image, specifying FRAME_FIRST
// to ensure that we don't get an animated decode.
RefPtr<SourceSurface> surface =
image->GetFrame(imgIContainer::FRAME_FIRST,
imgIContainer::FLAG_SYNC_DECODE);
// Ensure that the image's metadata meets our expectations.
IntSize imageSize(0, 0);
rv = image->GetWidth(&imageSize.width);
EXPECT_TRUE(NS_SUCCEEDED(rv));
rv = image->GetHeight(&imageSize.height);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_EQ(aTestCase.mSize.width, imageSize.width);
EXPECT_EQ(aTestCase.mSize.height, imageSize.height);
Progress imageProgress = tracker->GetProgress();
EXPECT_TRUE(bool(imageProgress & FLAG_HAS_TRANSPARENCY) == false);
EXPECT_TRUE(bool(imageProgress & FLAG_IS_ANIMATED) == true);
// Ensure that we decoded the static version of the image.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eStatic),
/* aMarkUsed = */ false);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(bool(result.Surface()));
}
// Ensure that we didn't decode the animated version of the image.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eAnimated),
/* aMarkUsed = */ false);
ASSERT_EQ(MatchType::NOT_FOUND, result.Type());
}
// Use GetFrame() to force a sync decode of the image, this time specifying
// FRAME_CURRENT to ensure that we get an animated decode.
RefPtr<SourceSurface> animatedSurface =
image->GetFrame(imgIContainer::FRAME_CURRENT,
imgIContainer::FLAG_SYNC_DECODE);
// Ensure that we decoded both frames of the animated version of the image.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eAnimated),
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(NS_SUCCEEDED(result.Surface().Seek(0)));
EXPECT_TRUE(bool(result.Surface()));
RefPtr<imgFrame> partialFrame = result.Surface().GetFrame(1);
EXPECT_TRUE(bool(partialFrame));
}
// Ensure that the static version is still around.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eStatic),
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(bool(result.Surface()));
}
}
static void
CheckDecoderFrameCurrent(const ImageTestCase& aTestCase)
{
// Verify that we can decode this test case and retrieve the entire sequence
// of frames using imgIContainer::FRAME_CURRENT. This ensures that we
// correctly trigger an animated decode rather than a single-frame decode when
// imgIContainer::FRAME_CURRENT is requested.
// Create an image.
RefPtr<Image> image =
ImageFactory::CreateAnonymousImage(nsDependentCString(aTestCase.mMimeType));
ASSERT_TRUE(!image->HasError());
nsCOMPtr<nsIInputStream> inputStream = LoadFile(aTestCase.mPath);
ASSERT_TRUE(inputStream);
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
// Write the data into the image.
rv = image->OnImageDataAvailable(nullptr, nullptr, inputStream, 0,
static_cast<uint32_t>(length));
ASSERT_TRUE(NS_SUCCEEDED(rv));
// Let the image know we've sent all the data.
rv = image->OnImageDataComplete(nullptr, nullptr, NS_OK, true);
ASSERT_TRUE(NS_SUCCEEDED(rv));
RefPtr<ProgressTracker> tracker = image->GetProgressTracker();
tracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
// Lock the image so its surfaces don't disappear during the test.
image->LockImage();
// Use GetFrame() to force a sync decode of the image, specifying
// FRAME_CURRENT to ensure we get an animated decode.
RefPtr<SourceSurface> surface =
image->GetFrame(imgIContainer::FRAME_CURRENT,
imgIContainer::FLAG_SYNC_DECODE);
// Ensure that the image's metadata meets our expectations.
IntSize imageSize(0, 0);
rv = image->GetWidth(&imageSize.width);
EXPECT_TRUE(NS_SUCCEEDED(rv));
rv = image->GetHeight(&imageSize.height);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_EQ(aTestCase.mSize.width, imageSize.width);
EXPECT_EQ(aTestCase.mSize.height, imageSize.height);
Progress imageProgress = tracker->GetProgress();
EXPECT_TRUE(bool(imageProgress & FLAG_HAS_TRANSPARENCY) == false);
EXPECT_TRUE(bool(imageProgress & FLAG_IS_ANIMATED) == true);
// Ensure that we decoded both frames of the animated version of the image.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eAnimated),
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(NS_SUCCEEDED(result.Surface().Seek(0)));
EXPECT_TRUE(bool(result.Surface()));
RefPtr<imgFrame> partialFrame = result.Surface().GetFrame(1);
EXPECT_TRUE(bool(partialFrame));
}
// Ensure that we didn't decode the static version of the image.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eStatic),
/* aMarkUsed = */ false);
ASSERT_EQ(MatchType::NOT_FOUND, result.Type());
}
// Use GetFrame() to force a sync decode of the image, this time specifying
// FRAME_FIRST to ensure that we get a single-frame decode.
RefPtr<SourceSurface> animatedSurface =
image->GetFrame(imgIContainer::FRAME_FIRST,
imgIContainer::FLAG_SYNC_DECODE);
// Ensure that we decoded the static version of the image.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eStatic),
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(bool(result.Surface()));
}
// Ensure that both frames of the animated version are still around.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eAnimated),
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(NS_SUCCEEDED(result.Surface().Seek(0)));
EXPECT_TRUE(bool(result.Surface()));
RefPtr<imgFrame> partialFrame = result.Surface().GetFrame(1);
EXPECT_TRUE(bool(partialFrame));
}
}
class ImageDecoders : public ::testing::Test
{
protected:
@ -430,6 +671,26 @@ TEST_F(ImageDecoders, IconDownscaleDuringDecode)
CheckDownscaleDuringDecode(DownscaledIconTestCase());
}
TEST_F(ImageDecoders, WebPSingleChunk)
{
CheckDecoderSingleChunk(GreenWebPTestCase());
}
TEST_F(ImageDecoders, WebPMultiChunk)
{
CheckDecoderMultiChunk(GreenWebPTestCase());
}
TEST_F(ImageDecoders, WebPDownscaleDuringDecode)
{
CheckDownscaleDuringDecode(DownscaledWebPTestCase());
}
TEST_F(ImageDecoders, WebPIccSrgbMultiChunk)
{
CheckDecoderMultiChunk(GreenWebPIccSrgbTestCase());
}
TEST_F(ImageDecoders, AnimatedGIFSingleChunk)
{
CheckDecoderSingleChunk(GreenFirstFrameAnimatedGIFTestCase());
@ -460,6 +721,21 @@ TEST_F(ImageDecoders, AnimatedPNGWithBlendedFrames)
CheckAnimationDecoderSingleChunk(GreenFirstFrameAnimatedPNGTestCase());
}
TEST_F(ImageDecoders, AnimatedWebPSingleChunk)
{
CheckDecoderSingleChunk(GreenFirstFrameAnimatedWebPTestCase());
}
TEST_F(ImageDecoders, AnimatedWebPMultiChunk)
{
CheckDecoderMultiChunk(GreenFirstFrameAnimatedWebPTestCase());
}
TEST_F(ImageDecoders, AnimatedWebPWithBlendedFrames)
{
CheckAnimationDecoderSingleChunk(GreenFirstFrameAnimatedWebPTestCase());
}
TEST_F(ImageDecoders, CorruptSingleChunk)
{
CheckDecoderSingleChunk(CorruptTestCase());
@ -507,245 +783,12 @@ TEST_F(ImageDecoders, CorruptICOWithBadBppSingleChunk)
TEST_F(ImageDecoders, AnimatedGIFWithFRAME_FIRST)
{
ImageTestCase testCase = GreenFirstFrameAnimatedGIFTestCase();
// Verify that we can decode this test case and retrieve the first frame using
// imgIContainer::FRAME_FIRST. This ensures that we correctly trigger a
// single-frame decode rather than an animated decode when
// imgIContainer::FRAME_FIRST is requested.
// Create an image.
RefPtr<Image> image =
ImageFactory::CreateAnonymousImage(nsDependentCString(testCase.mMimeType));
ASSERT_TRUE(!image->HasError());
nsCOMPtr<nsIInputStream> inputStream = LoadFile(testCase.mPath);
ASSERT_TRUE(inputStream);
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
// Write the data into the image.
rv = image->OnImageDataAvailable(nullptr, nullptr, inputStream, 0,
static_cast<uint32_t>(length));
ASSERT_TRUE(NS_SUCCEEDED(rv));
// Let the image know we've sent all the data.
rv = image->OnImageDataComplete(nullptr, nullptr, NS_OK, true);
ASSERT_TRUE(NS_SUCCEEDED(rv));
RefPtr<ProgressTracker> tracker = image->GetProgressTracker();
tracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
// Lock the image so its surfaces don't disappear during the test.
image->LockImage();
auto unlock = mozilla::MakeScopeExit([&] {
image->UnlockImage();
});
// Use GetFrame() to force a sync decode of the image, specifying FRAME_FIRST
// to ensure that we don't get an animated decode.
RefPtr<SourceSurface> surface =
image->GetFrame(imgIContainer::FRAME_FIRST,
imgIContainer::FLAG_SYNC_DECODE);
// Ensure that the image's metadata meets our expectations.
IntSize imageSize(0, 0);
rv = image->GetWidth(&imageSize.width);
EXPECT_TRUE(NS_SUCCEEDED(rv));
rv = image->GetHeight(&imageSize.height);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_EQ(testCase.mSize.width, imageSize.width);
EXPECT_EQ(testCase.mSize.height, imageSize.height);
Progress imageProgress = tracker->GetProgress();
EXPECT_TRUE(bool(imageProgress & FLAG_HAS_TRANSPARENCY) == false);
EXPECT_TRUE(bool(imageProgress & FLAG_IS_ANIMATED) == true);
// Ensure that we decoded the static version of the image.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eStatic),
/* aMarkUsed = */ false);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(bool(result.Surface()));
}
// Ensure that we didn't decode the animated version of the image.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eAnimated),
/* aMarkUsed = */ false);
ASSERT_EQ(MatchType::NOT_FOUND, result.Type());
}
// Use GetFrame() to force a sync decode of the image, this time specifying
// FRAME_CURRENT to ensure that we get an animated decode.
RefPtr<SourceSurface> animatedSurface =
image->GetFrame(imgIContainer::FRAME_CURRENT,
imgIContainer::FLAG_SYNC_DECODE);
// Ensure that we decoded both frames of the animated version of the image.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eAnimated),
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(NS_SUCCEEDED(result.Surface().Seek(0)));
EXPECT_TRUE(bool(result.Surface()));
RefPtr<imgFrame> partialFrame = result.Surface().GetFrame(1);
EXPECT_TRUE(bool(partialFrame));
}
// Ensure that the static version is still around.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eStatic),
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(bool(result.Surface()));
}
CheckDecoderFrameFirst(GreenFirstFrameAnimatedGIFTestCase());
}
TEST_F(ImageDecoders, AnimatedGIFWithFRAME_CURRENT)
{
ImageTestCase testCase = GreenFirstFrameAnimatedGIFTestCase();
// Verify that we can decode this test case and retrieve the entire sequence
// of frames using imgIContainer::FRAME_CURRENT. This ensures that we
// correctly trigger an animated decode rather than a single-frame decode when
// imgIContainer::FRAME_CURRENT is requested.
// Create an image.
RefPtr<Image> image =
ImageFactory::CreateAnonymousImage(nsDependentCString(testCase.mMimeType));
ASSERT_TRUE(!image->HasError());
nsCOMPtr<nsIInputStream> inputStream = LoadFile(testCase.mPath);
ASSERT_TRUE(inputStream);
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
// Write the data into the image.
rv = image->OnImageDataAvailable(nullptr, nullptr, inputStream, 0,
static_cast<uint32_t>(length));
ASSERT_TRUE(NS_SUCCEEDED(rv));
// Let the image know we've sent all the data.
rv = image->OnImageDataComplete(nullptr, nullptr, NS_OK, true);
ASSERT_TRUE(NS_SUCCEEDED(rv));
RefPtr<ProgressTracker> tracker = image->GetProgressTracker();
tracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
// Lock the image so its surfaces don't disappear during the test.
image->LockImage();
// Use GetFrame() to force a sync decode of the image, specifying
// FRAME_CURRENT to ensure we get an animated decode.
RefPtr<SourceSurface> surface =
image->GetFrame(imgIContainer::FRAME_CURRENT,
imgIContainer::FLAG_SYNC_DECODE);
// Ensure that the image's metadata meets our expectations.
IntSize imageSize(0, 0);
rv = image->GetWidth(&imageSize.width);
EXPECT_TRUE(NS_SUCCEEDED(rv));
rv = image->GetHeight(&imageSize.height);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_EQ(testCase.mSize.width, imageSize.width);
EXPECT_EQ(testCase.mSize.height, imageSize.height);
Progress imageProgress = tracker->GetProgress();
EXPECT_TRUE(bool(imageProgress & FLAG_HAS_TRANSPARENCY) == false);
EXPECT_TRUE(bool(imageProgress & FLAG_IS_ANIMATED) == true);
// Ensure that we decoded both frames of the animated version of the image.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eAnimated),
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(NS_SUCCEEDED(result.Surface().Seek(0)));
EXPECT_TRUE(bool(result.Surface()));
RefPtr<imgFrame> partialFrame = result.Surface().GetFrame(1);
EXPECT_TRUE(bool(partialFrame));
}
// Ensure that we didn't decode the static version of the image.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eStatic),
/* aMarkUsed = */ false);
ASSERT_EQ(MatchType::NOT_FOUND, result.Type());
}
// Use GetFrame() to force a sync decode of the image, this time specifying
// FRAME_FIRST to ensure that we get a single-frame decode.
RefPtr<SourceSurface> animatedSurface =
image->GetFrame(imgIContainer::FRAME_FIRST,
imgIContainer::FLAG_SYNC_DECODE);
// Ensure that we decoded the static version of the image.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eStatic),
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(bool(result.Surface()));
}
// Ensure that both frames of the animated version are still around.
{
LookupResult result =
SurfaceCache::Lookup(ImageKey(image.get()),
RasterSurfaceKey(imageSize,
DefaultSurfaceFlags(),
PlaybackType::eAnimated),
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(NS_SUCCEEDED(result.Surface().Seek(0)));
EXPECT_TRUE(bool(result.Surface()));
RefPtr<imgFrame> partialFrame = result.Surface().GetFrame(1);
EXPECT_TRUE(bool(partialFrame));
}
CheckDecoderFrameCurrent(GreenFirstFrameAnimatedGIFTestCase());
}
TEST_F(ImageDecoders, AnimatedGIFWithExtraImageSubBlocks)
@ -817,6 +860,16 @@ TEST_F(ImageDecoders, AnimatedGIFWithExtraImageSubBlocks)
EXPECT_TRUE(bool(partialFrame));
}
TEST_F(ImageDecoders, AnimatedWebPWithFRAME_FIRST)
{
CheckDecoderFrameFirst(GreenFirstFrameAnimatedWebPTestCase());
}
TEST_F(ImageDecoders, AnimatedWebPWithFRAME_CURRENT)
{
CheckDecoderFrameCurrent(GreenFirstFrameAnimatedWebPTestCase());
}
TEST_F(ImageDecoders, TruncatedSmallGIFSingleChunk)
{
CheckDecoderSingleChunk(TruncatedSmallGIFTestCase());

1
image/test/gtest/TestMetadata.cpp
View File

@ -153,6 +153,7 @@ TEST_F(ImageDecoderMetadata, JPG) { CheckMetadata(GreenJPGTestCase()); }
TEST_F(ImageDecoderMetadata, BMP) { CheckMetadata(GreenBMPTestCase()); }
TEST_F(ImageDecoderMetadata, ICO) { CheckMetadata(GreenICOTestCase()); }
TEST_F(ImageDecoderMetadata, Icon) { CheckMetadata(GreenIconTestCase()); }
TEST_F(ImageDecoderMetadata, WebP) { CheckMetadata(GreenWebPTestCase()); }
TEST_F(ImageDecoderMetadata, AnimatedGIF)
{

BIN
image/test/gtest/downscaled.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 56 B

BIN
image/test/gtest/first-frame-green.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 154 B

BIN
image/test/gtest/green.icc_srgb.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.0 KiB

BIN
image/test/gtest/green.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 42 B

4
image/test/gtest/moz.build
View File

@ -48,8 +48,10 @@ TEST_HARNESS_FILES.gtest += [
'downscaled.icon',
'downscaled.jpg',
'downscaled.png',
'downscaled.webp',
'first-frame-green.gif',
'first-frame-green.png',
'first-frame-green.webp',
'first-frame-padding.gif',
'green-1x1-truncated.gif',
'green-large-bmp.ico',
@ -57,10 +59,12 @@ TEST_HARNESS_FILES.gtest += [
'green-multiple-sizes.ico',
'green.bmp',
'green.gif',
'green.icc_srgb.webp',
'green.ico',
'green.icon',
'green.jpg',
'green.png',
'green.webp',
'invalid-truncated-metadata.bmp',
'no-frame-delay.gif',
'rle4.bmp',