mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-17 07:15:46 +00:00
e9f7db43b8
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.
362 lines
8.8 KiB
C++
362 lines
8.8 KiB
C++
/* -*- 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 "ImageWrapper.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
#include "mozilla/RefPtr.h"
|
|
#include "Orientation.h"
|
|
|
|
#include "mozilla/MemoryReporting.h"
|
|
|
|
namespace mozilla {
|
|
|
|
using gfx::DataSourceSurface;
|
|
using gfx::IntSize;
|
|
using gfx::SamplingFilter;
|
|
using gfx::SourceSurface;
|
|
using layers::LayerManager;
|
|
using layers::ImageContainer;
|
|
|
|
namespace image {
|
|
|
|
// Inherited methods from Image.
|
|
|
|
already_AddRefed<ProgressTracker>
|
|
ImageWrapper::GetProgressTracker()
|
|
{
|
|
return mInnerImage->GetProgressTracker();
|
|
}
|
|
|
|
size_t
|
|
ImageWrapper::SizeOfSourceWithComputedFallback(SizeOfState& aState) const
|
|
{
|
|
return mInnerImage->SizeOfSourceWithComputedFallback(aState);
|
|
}
|
|
|
|
void
|
|
ImageWrapper::CollectSizeOfSurfaces(nsTArray<SurfaceMemoryCounter>& aCounters,
|
|
MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
mInnerImage->CollectSizeOfSurfaces(aCounters, aMallocSizeOf);
|
|
}
|
|
|
|
void
|
|
ImageWrapper::IncrementAnimationConsumers()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread(), "Main thread only to encourage serialization "
|
|
"with DecrementAnimationConsumers");
|
|
mInnerImage->IncrementAnimationConsumers();
|
|
}
|
|
|
|
void
|
|
ImageWrapper::DecrementAnimationConsumers()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread(), "Main thread only to encourage serialization "
|
|
"with IncrementAnimationConsumers");
|
|
mInnerImage->DecrementAnimationConsumers();
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
uint32_t
|
|
ImageWrapper::GetAnimationConsumers()
|
|
{
|
|
return mInnerImage->GetAnimationConsumers();
|
|
}
|
|
#endif
|
|
|
|
nsresult
|
|
ImageWrapper::OnImageDataAvailable(nsIRequest* aRequest,
|
|
nsISupports* aContext,
|
|
nsIInputStream* aInStr,
|
|
uint64_t aSourceOffset,
|
|
uint32_t aCount)
|
|
{
|
|
return mInnerImage->OnImageDataAvailable(aRequest, aContext, aInStr,
|
|
aSourceOffset, aCount);
|
|
}
|
|
|
|
nsresult
|
|
ImageWrapper::OnImageDataComplete(nsIRequest* aRequest,
|
|
nsISupports* aContext,
|
|
nsresult aStatus,
|
|
bool aLastPart)
|
|
{
|
|
return mInnerImage->OnImageDataComplete(aRequest, aContext, aStatus,
|
|
aLastPart);
|
|
}
|
|
|
|
void
|
|
ImageWrapper::OnSurfaceDiscarded(const SurfaceKey& aSurfaceKey)
|
|
{
|
|
return mInnerImage->OnSurfaceDiscarded(aSurfaceKey);
|
|
}
|
|
|
|
void
|
|
ImageWrapper::SetInnerWindowID(uint64_t aInnerWindowId)
|
|
{
|
|
mInnerImage->SetInnerWindowID(aInnerWindowId);
|
|
}
|
|
|
|
uint64_t
|
|
ImageWrapper::InnerWindowID() const
|
|
{
|
|
return mInnerImage->InnerWindowID();
|
|
}
|
|
|
|
bool
|
|
ImageWrapper::HasError()
|
|
{
|
|
return mInnerImage->HasError();
|
|
}
|
|
|
|
void
|
|
ImageWrapper::SetHasError()
|
|
{
|
|
mInnerImage->SetHasError();
|
|
}
|
|
|
|
nsIURI*
|
|
ImageWrapper::GetURI() const
|
|
{
|
|
return mInnerImage->GetURI();
|
|
}
|
|
|
|
// Methods inherited from XPCOM interfaces.
|
|
|
|
NS_IMPL_ISUPPORTS(ImageWrapper, imgIContainer)
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::GetWidth(int32_t* aWidth)
|
|
{
|
|
return mInnerImage->GetWidth(aWidth);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::GetHeight(int32_t* aHeight)
|
|
{
|
|
return mInnerImage->GetHeight(aHeight);
|
|
}
|
|
|
|
nsresult
|
|
ImageWrapper::GetNativeSizes(nsTArray<IntSize>& aNativeSizes) const
|
|
{
|
|
return mInnerImage->GetNativeSizes(aNativeSizes);
|
|
}
|
|
|
|
size_t
|
|
ImageWrapper::GetNativeSizesLength() const
|
|
{
|
|
return mInnerImage->GetNativeSizesLength();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::GetIntrinsicSize(nsSize* aSize)
|
|
{
|
|
return mInnerImage->GetIntrinsicSize(aSize);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::GetIntrinsicRatio(nsSize* aSize)
|
|
{
|
|
return mInnerImage->GetIntrinsicRatio(aSize);
|
|
}
|
|
|
|
NS_IMETHODIMP_(Orientation)
|
|
ImageWrapper::GetOrientation()
|
|
{
|
|
return mInnerImage->GetOrientation();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::GetType(uint16_t* aType)
|
|
{
|
|
return mInnerImage->GetType(aType);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::GetAnimated(bool* aAnimated)
|
|
{
|
|
return mInnerImage->GetAnimated(aAnimated);
|
|
}
|
|
|
|
NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
|
|
ImageWrapper::GetFrame(uint32_t aWhichFrame,
|
|
uint32_t aFlags)
|
|
{
|
|
return mInnerImage->GetFrame(aWhichFrame, aFlags);
|
|
}
|
|
|
|
NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
|
|
ImageWrapper::GetFrameAtSize(const IntSize& aSize,
|
|
uint32_t aWhichFrame,
|
|
uint32_t aFlags)
|
|
{
|
|
return mInnerImage->GetFrameAtSize(aSize, aWhichFrame, aFlags);
|
|
}
|
|
|
|
NS_IMETHODIMP_(bool)
|
|
ImageWrapper::WillDrawOpaqueNow()
|
|
{
|
|
return mInnerImage->WillDrawOpaqueNow();
|
|
}
|
|
|
|
NS_IMETHODIMP_(bool)
|
|
ImageWrapper::IsImageContainerAvailable(LayerManager* aManager, uint32_t aFlags)
|
|
{
|
|
return mInnerImage->IsImageContainerAvailable(aManager, aFlags);
|
|
}
|
|
|
|
NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
|
|
ImageWrapper::GetImageContainer(LayerManager* aManager, uint32_t aFlags)
|
|
{
|
|
return mInnerImage->GetImageContainer(aManager, aFlags);
|
|
}
|
|
|
|
NS_IMETHODIMP_(bool)
|
|
ImageWrapper::IsImageContainerAvailableAtSize(LayerManager* aManager,
|
|
const IntSize& aSize,
|
|
uint32_t aFlags)
|
|
{
|
|
return mInnerImage->IsImageContainerAvailableAtSize(aManager, aSize, aFlags);
|
|
}
|
|
|
|
NS_IMETHODIMP_(ImgDrawResult)
|
|
ImageWrapper::GetImageContainerAtSize(layers::LayerManager* aManager,
|
|
const gfx::IntSize& aSize,
|
|
const Maybe<SVGImageContext>& aSVGContext,
|
|
uint32_t aFlags,
|
|
layers::ImageContainer** aOutContainer)
|
|
{
|
|
return mInnerImage->GetImageContainerAtSize(aManager, aSize, aSVGContext,
|
|
aFlags, aOutContainer);
|
|
}
|
|
|
|
NS_IMETHODIMP_(ImgDrawResult)
|
|
ImageWrapper::Draw(gfxContext* aContext,
|
|
const nsIntSize& aSize,
|
|
const ImageRegion& aRegion,
|
|
uint32_t aWhichFrame,
|
|
SamplingFilter aSamplingFilter,
|
|
const Maybe<SVGImageContext>& aSVGContext,
|
|
uint32_t aFlags,
|
|
float aOpacity)
|
|
{
|
|
return mInnerImage->Draw(aContext, aSize, aRegion, aWhichFrame,
|
|
aSamplingFilter, aSVGContext, aFlags, aOpacity);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::StartDecoding(uint32_t aFlags)
|
|
{
|
|
return mInnerImage->StartDecoding(aFlags);
|
|
}
|
|
|
|
bool
|
|
ImageWrapper::StartDecodingWithResult(uint32_t aFlags)
|
|
{
|
|
return mInnerImage->StartDecodingWithResult(aFlags);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::RequestDecodeForSize(const nsIntSize& aSize, uint32_t aFlags)
|
|
{
|
|
return mInnerImage->RequestDecodeForSize(aSize, aFlags);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::LockImage()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread(),
|
|
"Main thread to encourage serialization with UnlockImage");
|
|
return mInnerImage->LockImage();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::UnlockImage()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread(),
|
|
"Main thread to encourage serialization with LockImage");
|
|
return mInnerImage->UnlockImage();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::RequestDiscard()
|
|
{
|
|
return mInnerImage->RequestDiscard();
|
|
}
|
|
|
|
NS_IMETHODIMP_(void)
|
|
ImageWrapper::RequestRefresh(const TimeStamp& aTime)
|
|
{
|
|
return mInnerImage->RequestRefresh(aTime);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::GetAnimationMode(uint16_t* aAnimationMode)
|
|
{
|
|
return mInnerImage->GetAnimationMode(aAnimationMode);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::SetAnimationMode(uint16_t aAnimationMode)
|
|
{
|
|
return mInnerImage->SetAnimationMode(aAnimationMode);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ImageWrapper::ResetAnimation()
|
|
{
|
|
return mInnerImage->ResetAnimation();
|
|
}
|
|
|
|
NS_IMETHODIMP_(float)
|
|
ImageWrapper::GetFrameIndex(uint32_t aWhichFrame)
|
|
{
|
|
return mInnerImage->GetFrameIndex(aWhichFrame);
|
|
}
|
|
|
|
NS_IMETHODIMP_(int32_t)
|
|
ImageWrapper::GetFirstFrameDelay()
|
|
{
|
|
return mInnerImage->GetFirstFrameDelay();
|
|
}
|
|
|
|
NS_IMETHODIMP_(void)
|
|
ImageWrapper::SetAnimationStartTime(const TimeStamp& aTime)
|
|
{
|
|
mInnerImage->SetAnimationStartTime(aTime);
|
|
}
|
|
|
|
void
|
|
ImageWrapper::PropagateUseCounters(nsIDocument* aParentDocument)
|
|
{
|
|
mInnerImage->PropagateUseCounters(aParentDocument);
|
|
}
|
|
|
|
nsIntSize
|
|
ImageWrapper::OptimalImageSizeForDest(const gfxSize& aDest,
|
|
uint32_t aWhichFrame,
|
|
SamplingFilter aSamplingFilter,
|
|
uint32_t aFlags)
|
|
{
|
|
return mInnerImage->OptimalImageSizeForDest(aDest, aWhichFrame,
|
|
aSamplingFilter, aFlags);
|
|
}
|
|
|
|
NS_IMETHODIMP_(nsIntRect)
|
|
ImageWrapper::GetImageSpaceInvalidationRect(const nsIntRect& aRect)
|
|
{
|
|
return mInnerImage->GetImageSpaceInvalidationRect(aRect);
|
|
}
|
|
|
|
already_AddRefed<imgIContainer>
|
|
ImageWrapper::Unwrap()
|
|
{
|
|
return mInnerImage->Unwrap();
|
|
}
|
|
|
|
} // namespace image
|
|
} // namespace mozilla
|