mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-07 13:24:12 +00:00
d8ba79a56b
Renamed to imgDrawResult MozReview-Commit-ID: 5ESSgIhhU41 --HG-- rename : image/DrawResult.h => image/ImgDrawResult.h extra : rebase_source : dbf645574aff7eefe65fa81809d6c07cb5800ec6
361 lines
8.7 KiB
C++
361 lines
8.7 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();
|
|
}
|
|
|
|
ImageURL*
|
|
ImageWrapper::GetURI()
|
|
{
|
|
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_(already_AddRefed<ImageContainer>)
|
|
ImageWrapper::GetImageContainerAtSize(LayerManager* aManager,
|
|
const IntSize& aSize,
|
|
const Maybe<SVGImageContext>& aSVGContext,
|
|
uint32_t aFlags)
|
|
{
|
|
return mInnerImage->GetImageContainerAtSize(aManager, aSize,
|
|
aSVGContext, aFlags);
|
|
}
|
|
|
|
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
|