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

Bug 1446309 - Part 1. Return draw result from imgIContainer::GetImageContainerAtSize. r=tnikkel

Browse Source 
In addition to the image container, the draw result can also be useful
for callers to know whether or not the surface(s) in the container are
fully decoded or not. This is used in subsequent parts to avoid
flickering in some cases.
This commit is contained in:
Andrew Osmond 2018-09-13 19:48:21 -04:00
parent 0fdb26eeb5
commit e9f7db43b8
23 changed files with 205 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
image/ClippedImage.cpp
View File

@ -365,11 +365,12 @@ ClippedImage::IsImageContainerAvailableAtSize(LayerManager* aManager,
return false;
}
NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
ClippedImage::GetImageContainerAtSize(LayerManager* aManager,
const IntSize& aSize,
NS_IMETHODIMP_(ImgDrawResult)
ClippedImage::GetImageContainerAtSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags)
uint32_t aFlags,
layers::ImageContainer** aOutContainer)
{
// XXX(seth): We currently don't have a way of clipping the result of
// GetImageContainer. We work around this by always returning null, but if it
@ -378,11 +379,11 @@ ClippedImage::GetImageContainerAtSize(LayerManager* aManager,
// that method for performance reasons.
if (!ShouldClip()) {
return InnerImage()->GetImageContainerAtSize(aManager, aSize,
aSVGContext, aFlags);
return InnerImage()->GetImageContainerAtSize(aManager, aSize, aSVGContext,
aFlags, aOutContainer);
}
return nullptr;
return ImgDrawResult::NOT_SUPPORTED;
}
static bool

5
image/ClippedImage.h
View File

@ -51,11 +51,12 @@ public:
IsImageContainerAvailableAtSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
uint32_t aFlags) override;
NS_IMETHOD_(already_AddRefed<layers::ImageContainer>)
NS_IMETHOD_(ImgDrawResult)
GetImageContainerAtSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags) override;
uint32_t aFlags,
layers::ImageContainer** aOutContainer) override;
NS_IMETHOD_(ImgDrawResult) Draw(gfxContext* aContext,
const nsIntSize& aSize,
const ImageRegion& aRegion,

13
image/DynamicImage.cpp
View File

@ -234,13 +234,14 @@ DynamicImage::IsImageContainerAvailableAtSize(LayerManager* aManager,
return false;
}
NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
DynamicImage::GetImageContainerAtSize(LayerManager* aManager,
const IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags)
NS_IMETHODIMP_(ImgDrawResult)
DynamicImage::GetImageContainerAtSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags,
layers::ImageContainer** aContainer)
{
return nullptr;
return ImgDrawResult::NOT_SUPPORTED;
}
NS_IMETHODIMP_(ImgDrawResult)

9
image/FrozenImage.cpp
View File

@ -77,18 +77,19 @@ FrozenImage::IsImageContainerAvailableAtSize(LayerManager* aManager,
return false;
}
NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
NS_IMETHODIMP_(ImgDrawResult)
FrozenImage::GetImageContainerAtSize(layers::LayerManager* aManager,
const IntSize& aSize,
const gfx::IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags)
uint32_t aFlags,
layers::ImageContainer** aOutContainer)
{
// XXX(seth): GetImageContainer does not currently support anything but the
// current frame. We work around this by always returning null, but if it ever
// turns out that FrozenImage is widely used on codepaths that can actually
// benefit from GetImageContainer, it would be a good idea to fix that method
// for performance reasons.
return nullptr;
return ImgDrawResult::NOT_SUPPORTED;
}
NS_IMETHODIMP_(ImgDrawResult)

5
image/FrozenImage.h
View File

@ -50,11 +50,12 @@ public:
IsImageContainerAvailableAtSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
uint32_t aFlags) override;
NS_IMETHOD_(already_AddRefed<layers::ImageContainer>)
NS_IMETHOD_(ImgDrawResult)
GetImageContainerAtSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags) override;
uint32_t aFlags,
layers::ImageContainer** aOutContainer) override;
NS_IMETHOD_(ImgDrawResult) Draw(gfxContext* aContext,
const nsIntSize& aSize,
const ImageRegion& aRegion,

31
image/Image.cpp
View File

@ -104,11 +104,12 @@ ImageResource::SetCurrentImage(ImageContainer* aContainer,
}
}
already_AddRefed<ImageContainer>
ImgDrawResult
ImageResource::GetImageContainerImpl(LayerManager* aManager,
const IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags)
uint32_t aFlags,
ImageContainer** aOutContainer)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aManager);
@ -119,11 +120,15 @@ ImageResource::GetImageContainerImpl(LayerManager* aManager,
== FLAG_NONE,
"Unsupported flag passed to GetImageContainer");
IntSize size = GetImageContainerSize(aManager, aSize, aFlags);
if (size.IsEmpty()) {
return nullptr;
ImgDrawResult drawResult;
IntSize size;
Tie(drawResult, size) = GetImageContainerSize(aManager, aSize, aFlags);
if (drawResult != ImgDrawResult::SUCCESS) {
return drawResult;
}
MOZ_ASSERT(!size.IsEmpty());
if (mAnimationConsumers == 0) {
SendOnUnlockedDraw(aFlags);
}
@ -155,7 +160,8 @@ ImageResource::GetImageContainerImpl(LayerManager* aManager,
case ImgDrawResult::SUCCESS:
case ImgDrawResult::BAD_IMAGE:
case ImgDrawResult::BAD_ARGS:
return container.forget();
container.forget(aOutContainer);
return entry->mLastDrawResult;
case ImgDrawResult::NOT_READY:
case ImgDrawResult::INCOMPLETE:
case ImgDrawResult::TEMPORARY_ERROR:
@ -165,7 +171,8 @@ ImageResource::GetImageContainerImpl(LayerManager* aManager,
// Unused by GetFrameInternal
default:
MOZ_ASSERT_UNREACHABLE("Unhandled ImgDrawResult type!");
return container.forget();
container.forget(aOutContainer);
return entry->mLastDrawResult;
}
}
@ -173,7 +180,6 @@ ImageResource::GetImageContainerImpl(LayerManager* aManager,
NotifyDrawingObservers();
#endif
ImgDrawResult drawResult;
IntSize bestSize;
RefPtr<SourceSurface> surface;
Tie(drawResult, bestSize, surface) =
@ -212,7 +218,8 @@ ImageResource::GetImageContainerImpl(LayerManager* aManager,
case ImgDrawResult::SUCCESS:
case ImgDrawResult::BAD_IMAGE:
case ImgDrawResult::BAD_ARGS:
return container.forget();
container.forget(aOutContainer);
return entry->mLastDrawResult;
case ImgDrawResult::NOT_READY:
case ImgDrawResult::INCOMPLETE:
case ImgDrawResult::TEMPORARY_ERROR:
@ -223,7 +230,8 @@ ImageResource::GetImageContainerImpl(LayerManager* aManager,
// Unused by GetFrameInternal
default:
MOZ_ASSERT_UNREACHABLE("Unhandled DrawResult type!");
return container.forget();
container.forget(aOutContainer);
return entry->mLastDrawResult;
}
}
break;
@ -245,7 +253,8 @@ ImageResource::GetImageContainerImpl(LayerManager* aManager,
SetCurrentImage(container, surface, true);
entry->mLastDrawResult = drawResult;
return container.forget();
container.forget(aOutContainer);
return drawResult;
}
void

19
image/Image.h
View File

@ -353,18 +353,19 @@ protected:
* the same as the size of the surface in the image container, but it is the
* best effort estimate.
*/
virtual gfx::IntSize GetImageContainerSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
uint32_t aFlags)
virtual Tuple<ImgDrawResult, gfx::IntSize>
GetImageContainerSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
uint32_t aFlags)
{
return gfx::IntSize(0, 0);
return MakeTuple(ImgDrawResult::NOT_SUPPORTED, gfx::IntSize(0, 0));
}
already_AddRefed<layers::ImageContainer>
GetImageContainerImpl(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags);
ImgDrawResult GetImageContainerImpl(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags,
layers::ImageContainer** aContainer);
void UpdateImageContainer();

13
image/ImageWrapper.cpp
View File

@ -222,14 +222,15 @@ ImageWrapper::IsImageContainerAvailableAtSize(LayerManager* aManager,
return mInnerImage->IsImageContainerAvailableAtSize(aManager, aSize, aFlags);
}
NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
ImageWrapper::GetImageContainerAtSize(LayerManager* aManager,
const IntSize& aSize,
NS_IMETHODIMP_(ImgDrawResult)
ImageWrapper::GetImageContainerAtSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags)
uint32_t aFlags,
layers::ImageContainer** aOutContainer)
{
return mInnerImage->GetImageContainerAtSize(aManager, aSize,
aSVGContext, aFlags);
return mInnerImage->GetImageContainerAtSize(aManager, aSize, aSVGContext,
aFlags, aOutContainer);
}
NS_IMETHODIMP_(ImgDrawResult)

6
image/ImgDrawResult.h
View File

@ -51,6 +51,9 @@ namespace image {
* permanent condition.
*
* BAD_ARGS: We failed to draw because bad arguments were passed to draw().
*
* NOT_SUPPORTED: The requested operation is not supported, but the image is
* otherwise valid.
*/
enum class MOZ_MUST_USE_TYPE ImgDrawResult : uint8_t
{
@ -61,7 +64,8 @@ enum class MOZ_MUST_USE_TYPE ImgDrawResult : uint8_t
NOT_READY,
TEMPORARY_ERROR,
BAD_IMAGE,
BAD_ARGS
BAD_ARGS,
NOT_SUPPORTED
};
/**

15
image/OrientedImage.cpp
View File

@ -182,11 +182,12 @@ OrientedImage::IsImageContainerAvailableAtSize(LayerManager* aManager,
return false;
}
NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
OrientedImage::GetImageContainerAtSize(LayerManager* aManager,
const IntSize& aSize,
NS_IMETHODIMP_(ImgDrawResult)
OrientedImage::GetImageContainerAtSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags)
uint32_t aFlags,
layers::ImageContainer** aOutContainer)
{
// XXX(seth): We currently don't have a way of orienting the result of
// GetImageContainer. We work around this by always returning null, but if it
@ -195,11 +196,11 @@ OrientedImage::GetImageContainerAtSize(LayerManager* aManager,
// that method for performance reasons.
if (mOrientation.IsIdentity()) {
return InnerImage()->GetImageContainerAtSize(aManager, aSize,
aSVGContext, aFlags);
return InnerImage()->GetImageContainerAtSize(aManager, aSize, aSVGContext,
aFlags, aOutContainer);
}
return nullptr;
return ImgDrawResult::NOT_SUPPORTED;
}
struct MatrixBuilder

5
image/OrientedImage.h
View File

@ -48,11 +48,12 @@ public:
IsImageContainerAvailableAtSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
uint32_t aFlags) override;
NS_IMETHOD_(already_AddRefed<layers::ImageContainer>)
NS_IMETHOD_(ImgDrawResult)
GetImageContainerAtSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags) override;
uint32_t aFlags,
layers::ImageContainer** aOutContainer) override;
NS_IMETHOD_(ImgDrawResult) Draw(gfxContext* aContext,
const nsIntSize& aSize,
const ImageRegion& aRegion,

42
image/RasterImage.cpp
View File

@ -627,20 +627,34 @@ RasterImage::GetFrameInternal(const IntSize& aSize,
return MakeTuple(ImgDrawResult::SUCCESS, suggestedSize, std::move(surface));
}
IntSize
Tuple<ImgDrawResult, IntSize>
RasterImage::GetImageContainerSize(LayerManager* aManager,
const IntSize& aSize,
uint32_t aFlags)
{
if (!IsImageContainerAvailableAtSize(aManager, aSize, aFlags)) {
return IntSize(0, 0);
if (!mHasSize) {
return MakeTuple(ImgDrawResult::NOT_READY, IntSize(0, 0));
}
if (aSize.IsEmpty()) {
return MakeTuple(ImgDrawResult::BAD_ARGS, IntSize(0, 0));
}
// We check the minimum size because while we support downscaling, we do not
// support upscaling. If aSize > mSize, we will never give a larger surface
// than mSize. If mSize > aSize, and mSize > maxTextureSize, we still want to
// use image containers if aSize <= maxTextureSize.
int32_t maxTextureSize = aManager->GetMaxTextureSize();
if (min(mSize.width, aSize.width) > maxTextureSize ||
min(mSize.height, aSize.height) > maxTextureSize) {
return MakeTuple(ImgDrawResult::NOT_SUPPORTED, IntSize(0, 0));
}
if (!CanDownscaleDuringDecode(aSize, aFlags)) {
return mSize;
return MakeTuple(ImgDrawResult::SUCCESS, mSize);
}
return aSize;
return MakeTuple(ImgDrawResult::SUCCESS, aSize);
}
NS_IMETHODIMP_(bool)
@ -652,7 +666,11 @@ RasterImage::IsImageContainerAvailable(LayerManager* aManager, uint32_t aFlags)
NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
RasterImage::GetImageContainer(LayerManager* aManager, uint32_t aFlags)
{
return GetImageContainerImpl(aManager, mSize, Nothing(), aFlags);
RefPtr<ImageContainer> container;
ImgDrawResult drawResult =
GetImageContainerImpl(aManager, mSize, Nothing(), aFlags,
getter_AddRefs(container));
return container.forget();
}
NS_IMETHODIMP_(bool)
@ -674,16 +692,18 @@ RasterImage::IsImageContainerAvailableAtSize(LayerManager* aManager,
return true;
}
NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
RasterImage::GetImageContainerAtSize(LayerManager* aManager,
const IntSize& aSize,
NS_IMETHODIMP_(ImgDrawResult)
RasterImage::GetImageContainerAtSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags)
uint32_t aFlags,
layers::ImageContainer** aOutContainer)
{
// We do not pass in the given SVG context because in theory it could differ
// between calls, but actually have no impact on the actual contents of the
// image container.
return GetImageContainerImpl(aManager, aSize, Nothing(), aFlags);
return GetImageContainerImpl(aManager, aSize, Nothing(),
aFlags, aOutContainer);
}
size_t

7
image/RasterImage.h
View File

@ -312,9 +312,10 @@ private:
uint32_t aWhichFrame,
uint32_t aFlags) override;
gfx::IntSize GetImageContainerSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
uint32_t aFlags) override;
Tuple<ImgDrawResult, gfx::IntSize>
GetImageContainerSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
uint32_t aFlags) override;
//////////////////////////////////////////////////////////////////////////////
// Decoding.

34
image/VectorImage.cpp
View File

@ -849,16 +849,31 @@ VectorImage::GetFrameInternal(const IntSize& aSize,
}
//******************************************************************************
IntSize
Tuple<ImgDrawResult, IntSize>
VectorImage::GetImageContainerSize(LayerManager* aManager,
const IntSize& aSize,
uint32_t aFlags)
{
if (!IsImageContainerAvailableAtSize(aManager, aSize, aFlags)) {
return IntSize(0, 0);
if (mError) {
return MakeTuple(ImgDrawResult::BAD_IMAGE, IntSize(0, 0));
}
return aSize;
if (!mIsFullyLoaded) {
return MakeTuple(ImgDrawResult::NOT_READY, IntSize(0, 0));
}
if (mHaveAnimations ||
aManager->GetBackendType() != LayersBackend::LAYERS_WR) {
return MakeTuple(ImgDrawResult::NOT_SUPPORTED, IntSize(0, 0));
}
// We don't need to check if the size is too big since we only support
// WebRender backends.
if (aSize.IsEmpty()) {
return MakeTuple(ImgDrawResult::BAD_ARGS, IntSize(0, 0));
}
return MakeTuple(ImgDrawResult::SUCCESS, aSize);
}
NS_IMETHODIMP_(bool)
@ -893,11 +908,12 @@ VectorImage::IsImageContainerAvailableAtSize(LayerManager* aManager,
}
//******************************************************************************
NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
VectorImage::GetImageContainerAtSize(LayerManager* aManager,
const IntSize& aSize,
NS_IMETHODIMP_(ImgDrawResult)
VectorImage::GetImageContainerAtSize(layers::LayerManager* aManager,
const gfx::IntSize& aSize,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags)
uint32_t aFlags,
layers::ImageContainer** aOutContainer)
{
Maybe<SVGImageContext> newSVGContext;
MaybeRestrictSVGContext(newSVGContext, aSVGContext, aFlags);
@ -910,7 +926,7 @@ VectorImage::GetImageContainerAtSize(LayerManager* aManager,
FLAG_FORCE_PRESERVEASPECTRATIO_NONE);
return GetImageContainerImpl(aManager, aSize,
newSVGContext ? newSVGContext : aSVGContext,
flags);
flags, aOutContainer);
}
bool

7
image/VectorImage.h
View File

@ -87,9 +87,10 @@ private:
uint32_t aWhichFrame,
uint32_t aFlags) override;
IntSize GetImageContainerSize(layers::LayerManager* aManager,
const IntSize& aSize,
uint32_t aFlags) override;
Tuple<ImgDrawResult, IntSize>
GetImageContainerSize(layers::LayerManager* aManager,
const IntSize& aSize,
uint32_t aFlags) override;
/// Attempt to find a matching cached surface in the SurfaceCache.
already_AddRefed<SourceSurface>

33
image/imgIContainer.idl
View File

@ -57,6 +57,7 @@ native nsIntRectByVal(nsIntRect);
native nsSize(nsSize);
[ptr] native nsIFrame(nsIFrame);
native TempRefImageContainer(already_AddRefed<mozilla::layers::ImageContainer>);
[ptr] native ImageContainer(mozilla::layers::ImageContainer);
[ref] native ImageRegion(mozilla::image::ImageRegion);
[ptr] native LayerManager(mozilla::layers::LayerManager);
native Orientation(mozilla::image::Orientation);
@ -295,15 +296,6 @@ interface imgIContainer : nsISupports
[noscript, notxpcom] TempRefImageContainer getImageContainer(in LayerManager aManager,
in uint32_t aFlags);
/**
* @return true if getImageContainer() is expected to return a valid
* ImageContainer when passed the given @Manager, @Size and @Flags
* parameters.
*/
[noscript, notxpcom] boolean isImageContainerAvailableAtSize(in LayerManager aManager,
[const] in nsIntSize aSize,
in uint32_t aFlags);
/**
* Attempts to create an ImageContainer (and Image) containing the current
* frame at the given size. Match the requested size is best effort; it's
@ -322,13 +314,24 @@ interface imgIContainer : nsISupports
* @param aFlags Decoding / drawing flags (in other words, FLAG_* flags).
* Currently only FLAG_SYNC_DECODE and FLAG_SYNC_DECODE_IF_FAST
* are supported.
* @return An ImageContainer for the current frame, or nullptr if one could
* not be created.
* @param aContainer Return value for ImageContainer for the current frame.
* May be null depending on the draw result.
* @return The draw result for the current frame.
*/
[noscript, notxpcom] TempRefImageContainer getImageContainerAtSize(in LayerManager aManager,
[const] in nsIntSize aSize,
[const] in MaybeSVGImageContext aSVGContext,
in uint32_t aFlags);
[noscript, notxpcom] ImgDrawResult getImageContainerAtSize(in LayerManager aManager,
[const] in nsIntSize aSize,
[const] in MaybeSVGImageContext aSVGContext,
in uint32_t aFlags,
out ImageContainer aOutContainer);
/**
* @return true if getImageContainer() is expected to return a valid
* ImageContainer when passed the given @Manager, @Size and @Flags
* parameters.
*/
[noscript, notxpcom] boolean isImageContainerAvailableAtSize(in LayerManager aManager,
[const] in nsIntSize aSize,
in uint32_t aFlags);
/**
* Draw the requested frame of this image onto the context specified.

38
image/test/gtest/TestContainers.cpp
View File

@ -68,14 +68,16 @@ TEST_F(ImageContainers, RasterImageContainer)
EXPECT_EQ(testCase.mSize.height, containerSize.height);
// Upscaling should give the native size.
ImgDrawResult drawResult;
IntSize requestedSize = testCase.mSize;
requestedSize.Scale(2, 2);
RefPtr<layers::ImageContainer> upscaleContainer =
image->GetImageContainerAtSize(layerManager,
requestedSize,
Nothing(),
imgIContainer::FLAG_SYNC_DECODE |
imgIContainer::FLAG_HIGH_QUALITY_SCALING);
RefPtr<layers::ImageContainer> upscaleContainer;
drawResult = image->GetImageContainerAtSize(layerManager,
requestedSize,
Nothing(),
imgIContainer::FLAG_SYNC_DECODE |
imgIContainer::FLAG_HIGH_QUALITY_SCALING,
getter_AddRefs(upscaleContainer));
ASSERT_TRUE(upscaleContainer != nullptr);
containerSize = upscaleContainer->GetCurrentSize();
EXPECT_EQ(testCase.mSize.width, containerSize.width);
@ -85,21 +87,23 @@ TEST_F(ImageContainers, RasterImageContainer)
requestedSize = testCase.mSize;
requestedSize.width /= 2;
requestedSize.height /= 2;
RefPtr<layers::ImageContainer> downscaleContainer =
image->GetImageContainerAtSize(layerManager,
requestedSize,
Nothing(),
imgIContainer::FLAG_SYNC_DECODE |
imgIContainer::FLAG_HIGH_QUALITY_SCALING);
RefPtr<layers::ImageContainer> downscaleContainer;
drawResult = image->GetImageContainerAtSize(layerManager,
requestedSize,
Nothing(),
imgIContainer::FLAG_SYNC_DECODE |
imgIContainer::FLAG_HIGH_QUALITY_SCALING,
getter_AddRefs(downscaleContainer));
containerSize = downscaleContainer->GetCurrentSize();
EXPECT_EQ(requestedSize.width, containerSize.width);
EXPECT_EQ(requestedSize.height, containerSize.height);
// Get at native size again. Should give same container.
RefPtr<layers::ImageContainer> againContainer =
image->GetImageContainerAtSize(layerManager,
testCase.mSize,
Nothing(),
imgIContainer::FLAG_SYNC_DECODE);
RefPtr<layers::ImageContainer> againContainer;
drawResult = image->GetImageContainerAtSize(layerManager,
testCase.mSize,
Nothing(),
imgIContainer::FLAG_SYNC_DECODE,
getter_AddRefs(againContainer));
ASSERT_EQ(nativeContainer.get(), againContainer.get());
}

6
layout/generic/nsBulletFrame.cpp
View File

@ -479,8 +479,10 @@ BulletRenderer::CreateWebRenderCommandsForImage(nsDisplayItem* aItem,
gfx::IntSize decodeSize =
nsLayoutUtils::ComputeImageContainerDrawingParameters(mImage, aItem->Frame(), destRect,
aSc, flags, svgContext);
RefPtr<layers::ImageContainer> container =
mImage->GetImageContainerAtSize(aManager, decodeSize, svgContext, flags);
RefPtr<layers::ImageContainer> container;
mImage->GetImageContainerAtSize(aManager, decodeSize, svgContext,
flags, getter_AddRefs(container));
if (!container) {
return false;
}

7
layout/generic/nsImageFrame.cpp
View File

@ -1814,8 +1814,11 @@ nsDisplayImage::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilde
IntSize decodeSize =
nsLayoutUtils::ComputeImageContainerDrawingParameters(mImage, mFrame, destRect,
aSc, flags, svgContext);
RefPtr<ImageContainer> container =
mImage->GetImageContainerAtSize(aManager, decodeSize, svgContext, flags);
RefPtr<layers::ImageContainer> container;
ImgDrawResult drawResult =
mImage->GetImageContainerAtSize(aManager, decodeSize, svgContext,
flags, getter_AddRefs(container));
if (!container) {
return false;
}

6
layout/painting/nsCSSRenderingBorders.cpp
View File

@ -3853,8 +3853,10 @@ nsCSSBorderImageRenderer::CreateWebRenderCommands(
gfx::IntSize decodeSize =
nsLayoutUtils::ComputeImageContainerDrawingParameters(
img, aForFrame, destRect, aSc, flags, svgContext);
RefPtr<layers::ImageContainer> container =
img->GetImageContainerAtSize(aManager, decodeSize, svgContext, flags);
RefPtr<layers::ImageContainer> container;
img->GetImageContainerAtSize(aManager, decodeSize, svgContext,
flags, getter_AddRefs(container));
if (!container) {
return;
}

7
layout/painting/nsImageRenderer.cpp
View File

@ -641,9 +641,10 @@ nsImageRenderer::BuildWebRenderDisplayItems(
aSc,
containerFlags,
svgContext);
RefPtr<layers::ImageContainer> container =
mImageContainer->GetImageContainerAtSize(
aManager, decodeSize, svgContext, containerFlags);
RefPtr<layers::ImageContainer> container;
mImageContainer->GetImageContainerAtSize(aManager, decodeSize, svgContext,
containerFlags, getter_AddRefs(container));
if (!container) {
NS_WARNING("Failed to get image container");
return ImgDrawResult::NOT_READY;

6
layout/xul/nsImageBoxFrame.cpp
View File

@ -452,8 +452,10 @@ nsImageBoxFrame::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuild
gfx::IntSize decodeSize =
nsLayoutUtils::ComputeImageContainerDrawingParameters(imgCon, aItem->Frame(), fillRect,
aSc, containerFlags, svgContext);
RefPtr<layers::ImageContainer> container =
imgCon->GetImageContainerAtSize(aManager, decodeSize, svgContext, containerFlags);
RefPtr<layers::ImageContainer> container;
imgCon->GetImageContainerAtSize(aManager, decodeSize, svgContext,
containerFlags, getter_AddRefs(container));
if (!container) {
NS_WARNING("Failed to get image container");
return Nothing();

3
widget/nsBaseDragService.cpp
View File

@ -789,7 +789,8 @@ nsBaseDragService::DrawDragForImage(nsPresContext* aPresContext,
imgIContainer::FRAME_CURRENT,
SamplingFilter::GOOD, /* no SVGImageContext */ Nothing(),
imgIContainer::FLAG_SYNC_DECODE, 1.0);
if (res == ImgDrawResult::BAD_IMAGE || res == ImgDrawResult::BAD_ARGS) {
if (res == ImgDrawResult::BAD_IMAGE || res == ImgDrawResult::BAD_ARGS ||
res == ImgDrawResult::NOT_SUPPORTED) {
return NS_ERROR_FAILURE;
}
*aSurface = dt->Snapshot();