2013-04-05 21:14:32 +00:00
|
|
|
/* -*- 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 "gfxDrawable.h"
|
|
|
|
#include "gfxPlatform.h"
|
|
|
|
#include "gfxUtils.h"
|
2014-04-15 18:02:23 +00:00
|
|
|
#include "mozilla/gfx/2D.h"
|
|
|
|
#include "mozilla/RefPtr.h"
|
2013-04-05 21:14:32 +00:00
|
|
|
|
|
|
|
#include "ClippedImage.h"
|
2013-08-25 07:19:42 +00:00
|
|
|
#include "Orientation.h"
|
2013-09-07 13:01:08 +00:00
|
|
|
#include "SVGImageContext.h"
|
2013-04-05 21:14:32 +00:00
|
|
|
|
2014-04-15 18:02:23 +00:00
|
|
|
using namespace mozilla;
|
|
|
|
using namespace mozilla::gfx;
|
2013-04-05 21:14:32 +00:00
|
|
|
using mozilla::layers::LayerManager;
|
|
|
|
using mozilla::layers::ImageContainer;
|
|
|
|
|
|
|
|
namespace mozilla {
|
|
|
|
namespace image {
|
|
|
|
|
2013-04-25 22:58:32 +00:00
|
|
|
class ClippedImageCachedSurface
|
|
|
|
{
|
|
|
|
public:
|
2014-04-15 18:02:23 +00:00
|
|
|
ClippedImageCachedSurface(TemporaryRef<SourceSurface> aSurface,
|
2013-04-25 22:58:32 +00:00
|
|
|
const nsIntSize& aViewportSize,
|
|
|
|
const SVGImageContext* aSVGContext,
|
|
|
|
float aFrame,
|
|
|
|
uint32_t aFlags)
|
|
|
|
: mSurface(aSurface)
|
|
|
|
, mViewportSize(aViewportSize)
|
|
|
|
, mFrame(aFrame)
|
|
|
|
, mFlags(aFlags)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(mSurface, "Must have a valid surface");
|
|
|
|
if (aSVGContext) {
|
|
|
|
mSVGContext.construct(*aSVGContext);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Matches(const nsIntSize& aViewportSize,
|
|
|
|
const SVGImageContext* aSVGContext,
|
|
|
|
float aFrame,
|
|
|
|
uint32_t aFlags)
|
|
|
|
{
|
|
|
|
bool matchesSVGContext = (!aSVGContext && mSVGContext.empty()) ||
|
|
|
|
*aSVGContext == mSVGContext.ref();
|
|
|
|
return mViewportSize == aViewportSize &&
|
|
|
|
matchesSVGContext &&
|
|
|
|
mFrame == aFrame &&
|
|
|
|
mFlags == aFlags;
|
|
|
|
}
|
|
|
|
|
2014-04-15 18:02:23 +00:00
|
|
|
TemporaryRef<SourceSurface> Surface() {
|
|
|
|
return mSurface;
|
2013-05-07 17:47:42 +00:00
|
|
|
}
|
2013-04-25 22:58:32 +00:00
|
|
|
|
|
|
|
private:
|
2014-04-15 18:02:23 +00:00
|
|
|
RefPtr<SourceSurface> mSurface;
|
2013-05-07 17:47:42 +00:00
|
|
|
const nsIntSize mViewportSize;
|
|
|
|
Maybe<SVGImageContext> mSVGContext;
|
|
|
|
const float mFrame;
|
|
|
|
const uint32_t mFlags;
|
2013-04-25 22:58:32 +00:00
|
|
|
};
|
|
|
|
|
2013-04-05 21:14:32 +00:00
|
|
|
class DrawSingleTileCallback : public gfxDrawingCallback
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
DrawSingleTileCallback(ClippedImage* aImage,
|
|
|
|
const nsIntRect& aClip,
|
|
|
|
const nsIntSize& aViewportSize,
|
|
|
|
const SVGImageContext* aSVGContext,
|
|
|
|
uint32_t aWhichFrame,
|
|
|
|
uint32_t aFlags)
|
|
|
|
: mImage(aImage)
|
|
|
|
, mClip(aClip)
|
|
|
|
, mViewportSize(aViewportSize)
|
|
|
|
, mSVGContext(aSVGContext)
|
|
|
|
, mWhichFrame(aWhichFrame)
|
|
|
|
, mFlags(aFlags)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(mImage, "Must have an image to clip");
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual bool operator()(gfxContext* aContext,
|
|
|
|
const gfxRect& aFillRect,
|
2013-10-01 21:01:19 +00:00
|
|
|
const GraphicsFilter& aFilter,
|
2013-04-05 21:14:32 +00:00
|
|
|
const gfxMatrix& aTransform)
|
|
|
|
{
|
|
|
|
// Draw the image. |gfxCallbackDrawable| always calls this function with
|
|
|
|
// arguments that guarantee we never tile.
|
|
|
|
mImage->DrawSingleTile(aContext, aFilter, aTransform, aFillRect, mClip,
|
|
|
|
mViewportSize, mSVGContext, mWhichFrame, mFlags);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
nsRefPtr<ClippedImage> mImage;
|
|
|
|
const nsIntRect mClip;
|
|
|
|
const nsIntSize mViewportSize;
|
|
|
|
const SVGImageContext* mSVGContext;
|
|
|
|
const uint32_t mWhichFrame;
|
|
|
|
const uint32_t mFlags;
|
|
|
|
};
|
|
|
|
|
|
|
|
ClippedImage::ClippedImage(Image* aImage,
|
|
|
|
nsIntRect aClip)
|
|
|
|
: ImageWrapper(aImage)
|
|
|
|
, mClip(aClip)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(aImage != nullptr, "ClippedImage requires an existing Image");
|
|
|
|
}
|
|
|
|
|
2013-04-25 22:58:32 +00:00
|
|
|
ClippedImage::~ClippedImage()
|
|
|
|
{ }
|
|
|
|
|
2013-04-05 21:14:32 +00:00
|
|
|
bool
|
|
|
|
ClippedImage::ShouldClip()
|
|
|
|
{
|
|
|
|
// We need to evaluate the clipping region against the image's width and height
|
|
|
|
// once they're available to determine if it's valid and whether we actually
|
|
|
|
// need to do any work. We may fail if the image's width and height aren't
|
|
|
|
// available yet, in which case we'll try again later.
|
|
|
|
if (mShouldClip.empty()) {
|
|
|
|
int32_t width, height;
|
2013-09-28 18:28:44 +00:00
|
|
|
nsRefPtr<imgStatusTracker> innerImageStatusTracker =
|
|
|
|
InnerImage()->GetStatusTracker();
|
2013-04-05 21:14:32 +00:00
|
|
|
if (InnerImage()->HasError()) {
|
|
|
|
// If there's a problem with the inner image we'll let it handle everything.
|
|
|
|
mShouldClip.construct(false);
|
|
|
|
} else if (NS_SUCCEEDED(InnerImage()->GetWidth(&width)) && width > 0 &&
|
|
|
|
NS_SUCCEEDED(InnerImage()->GetHeight(&height)) && height > 0) {
|
|
|
|
// Clamp the clipping region to the size of the underlying image.
|
|
|
|
mClip = mClip.Intersect(nsIntRect(0, 0, width, height));
|
|
|
|
|
|
|
|
// If the clipping region is the same size as the underlying image we
|
|
|
|
// don't have to do anything.
|
|
|
|
mShouldClip.construct(!mClip.IsEqualInterior(nsIntRect(0, 0, width, height)));
|
2013-09-28 18:28:44 +00:00
|
|
|
} else if (innerImageStatusTracker &&
|
|
|
|
innerImageStatusTracker->IsLoading()) {
|
2013-04-05 21:14:32 +00:00
|
|
|
// The image just hasn't finished loading yet. We don't yet know whether
|
|
|
|
// clipping with be needed or not for now. Just return without memoizing
|
|
|
|
// anything.
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
// We have a fully loaded image without a clearly defined width and
|
|
|
|
// height. This can happen with SVG images.
|
|
|
|
mShouldClip.construct(false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
MOZ_ASSERT(!mShouldClip.empty(), "Should have computed a result");
|
|
|
|
return mShouldClip.ref();
|
|
|
|
}
|
|
|
|
|
2014-04-27 07:06:00 +00:00
|
|
|
NS_IMPL_ISUPPORTS(ClippedImage, imgIContainer)
|
2013-04-05 21:14:32 +00:00
|
|
|
|
|
|
|
nsIntRect
|
|
|
|
ClippedImage::FrameRect(uint32_t aWhichFrame)
|
|
|
|
{
|
|
|
|
if (!ShouldClip()) {
|
|
|
|
return InnerImage()->FrameRect(aWhichFrame);
|
|
|
|
}
|
|
|
|
|
|
|
|
return nsIntRect(0, 0, mClip.width, mClip.height);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
ClippedImage::GetWidth(int32_t* aWidth)
|
|
|
|
{
|
|
|
|
if (!ShouldClip()) {
|
|
|
|
return InnerImage()->GetWidth(aWidth);
|
|
|
|
}
|
|
|
|
|
|
|
|
*aWidth = mClip.width;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
ClippedImage::GetHeight(int32_t* aHeight)
|
|
|
|
{
|
|
|
|
if (!ShouldClip()) {
|
|
|
|
return InnerImage()->GetHeight(aHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
*aHeight = mClip.height;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
ClippedImage::GetIntrinsicSize(nsSize* aSize)
|
|
|
|
{
|
|
|
|
if (!ShouldClip()) {
|
|
|
|
return InnerImage()->GetIntrinsicSize(aSize);
|
|
|
|
}
|
|
|
|
|
|
|
|
*aSize = nsSize(mClip.width, mClip.height);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
ClippedImage::GetIntrinsicRatio(nsSize* aRatio)
|
|
|
|
{
|
|
|
|
if (!ShouldClip()) {
|
|
|
|
return InnerImage()->GetIntrinsicRatio(aRatio);
|
|
|
|
}
|
|
|
|
|
|
|
|
*aRatio = nsSize(mClip.width, mClip.height);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-04-15 18:02:23 +00:00
|
|
|
NS_IMETHODIMP_(TemporaryRef<SourceSurface>)
|
2013-04-05 21:14:32 +00:00
|
|
|
ClippedImage::GetFrame(uint32_t aWhichFrame,
|
2013-12-13 08:34:24 +00:00
|
|
|
uint32_t aFlags)
|
2013-04-05 21:14:32 +00:00
|
|
|
{
|
2013-12-13 08:34:24 +00:00
|
|
|
return GetFrameInternal(mClip.Size(), nullptr, aWhichFrame, aFlags);
|
2013-04-05 21:14:32 +00:00
|
|
|
}
|
|
|
|
|
2014-04-15 18:02:23 +00:00
|
|
|
TemporaryRef<SourceSurface>
|
2013-04-05 21:14:32 +00:00
|
|
|
ClippedImage::GetFrameInternal(const nsIntSize& aViewportSize,
|
|
|
|
const SVGImageContext* aSVGContext,
|
|
|
|
uint32_t aWhichFrame,
|
2013-12-13 08:34:24 +00:00
|
|
|
uint32_t aFlags)
|
2013-04-05 21:14:32 +00:00
|
|
|
{
|
|
|
|
if (!ShouldClip()) {
|
2013-12-13 08:34:24 +00:00
|
|
|
return InnerImage()->GetFrame(aWhichFrame, aFlags);
|
2013-04-05 21:14:32 +00:00
|
|
|
}
|
|
|
|
|
2013-04-25 22:58:32 +00:00
|
|
|
float frameToDraw = InnerImage()->GetFrameIndex(aWhichFrame);
|
|
|
|
if (!mCachedSurface || !mCachedSurface->Matches(aViewportSize,
|
|
|
|
aSVGContext,
|
|
|
|
frameToDraw,
|
|
|
|
aFlags)) {
|
|
|
|
// Create a surface to draw into.
|
2014-04-15 18:02:23 +00:00
|
|
|
RefPtr<DrawTarget> target = gfxPlatform::GetPlatform()->
|
|
|
|
CreateOffscreenContentDrawTarget(IntSize(mClip.width, mClip.height),
|
|
|
|
SurfaceFormat::B8G8R8A8);
|
2013-10-16 01:00:30 +00:00
|
|
|
|
2014-04-15 18:02:23 +00:00
|
|
|
nsRefPtr<gfxContext> ctx = new gfxContext(target);
|
2013-04-25 22:58:32 +00:00
|
|
|
|
|
|
|
// Create our callback.
|
|
|
|
nsRefPtr<gfxDrawingCallback> drawTileCallback =
|
|
|
|
new DrawSingleTileCallback(this, mClip, aViewportSize, aSVGContext, aWhichFrame, aFlags);
|
|
|
|
nsRefPtr<gfxDrawable> drawable =
|
|
|
|
new gfxCallbackDrawable(drawTileCallback, mClip.Size());
|
|
|
|
|
|
|
|
// Actually draw. The callback will end up invoking DrawSingleTile.
|
|
|
|
gfxRect imageRect(0, 0, mClip.width, mClip.height);
|
|
|
|
gfxUtils::DrawPixelSnapped(ctx, drawable, gfxMatrix(),
|
|
|
|
imageRect, imageRect, imageRect, imageRect,
|
2014-01-23 18:26:40 +00:00
|
|
|
gfxImageFormat::ARGB32,
|
2013-10-01 21:01:19 +00:00
|
|
|
GraphicsFilter::FILTER_FAST);
|
2013-04-25 22:58:32 +00:00
|
|
|
|
|
|
|
// Cache the resulting surface.
|
2014-04-15 18:02:23 +00:00
|
|
|
mCachedSurface = new ClippedImageCachedSurface(target->Snapshot(),
|
2013-04-25 22:58:32 +00:00
|
|
|
aViewportSize,
|
|
|
|
aSVGContext,
|
|
|
|
frameToDraw,
|
|
|
|
aFlags);
|
|
|
|
}
|
|
|
|
|
|
|
|
MOZ_ASSERT(mCachedSurface, "Should have a cached surface now");
|
2013-12-13 08:34:24 +00:00
|
|
|
return mCachedSurface->Surface();
|
2013-04-05 21:14:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
ClippedImage::GetImageContainer(LayerManager* aManager, ImageContainer** _retval)
|
|
|
|
{
|
|
|
|
// 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
|
|
|
|
// ever turns out that ClippedImage is widely used on codepaths that can
|
|
|
|
// actually benefit from GetImageContainer, it would be a good idea to fix
|
|
|
|
// that method for performance reasons.
|
|
|
|
|
2013-04-25 22:58:32 +00:00
|
|
|
if (!ShouldClip()) {
|
|
|
|
return InnerImage()->GetImageContainer(aManager, _retval);
|
|
|
|
}
|
|
|
|
|
2013-04-05 21:14:32 +00:00
|
|
|
*_retval = nullptr;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ClippedImage::MustCreateSurface(gfxContext* aContext,
|
|
|
|
const gfxMatrix& aTransform,
|
|
|
|
const gfxRect& aSourceRect,
|
|
|
|
const nsIntRect& aSubimage,
|
|
|
|
const uint32_t aFlags) const
|
|
|
|
{
|
|
|
|
gfxRect gfxImageRect(0, 0, mClip.width, mClip.height);
|
|
|
|
nsIntRect intImageRect(0, 0, mClip.width, mClip.height);
|
|
|
|
bool willTile = !gfxImageRect.Contains(aSourceRect) &&
|
|
|
|
!(aFlags & imgIContainer::FLAG_CLAMP);
|
|
|
|
bool willResample = (aContext->CurrentMatrix().HasNonIntegerTranslation() ||
|
|
|
|
aTransform.HasNonIntegerTranslation()) &&
|
|
|
|
(willTile || !aSubimage.Contains(intImageRect));
|
|
|
|
return willTile || willResample;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
ClippedImage::Draw(gfxContext* aContext,
|
2013-10-01 21:01:19 +00:00
|
|
|
GraphicsFilter aFilter,
|
2013-04-05 21:14:32 +00:00
|
|
|
const gfxMatrix& aUserSpaceToImageSpace,
|
|
|
|
const gfxRect& aFill,
|
|
|
|
const nsIntRect& aSubimage,
|
|
|
|
const nsIntSize& aViewportSize,
|
|
|
|
const SVGImageContext* aSVGContext,
|
|
|
|
uint32_t aWhichFrame,
|
|
|
|
uint32_t aFlags)
|
|
|
|
{
|
|
|
|
if (!ShouldClip()) {
|
|
|
|
return InnerImage()->Draw(aContext, aFilter, aUserSpaceToImageSpace,
|
|
|
|
aFill, aSubimage, aViewportSize, aSVGContext,
|
|
|
|
aWhichFrame, aFlags);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check for tiling. If we need to tile then we need to create a
|
|
|
|
// gfxCallbackDrawable to handle drawing for us.
|
|
|
|
gfxRect sourceRect = aUserSpaceToImageSpace.Transform(aFill);
|
|
|
|
if (MustCreateSurface(aContext, aUserSpaceToImageSpace, sourceRect, aSubimage, aFlags)) {
|
|
|
|
// Create a temporary surface containing a single tile of this image.
|
|
|
|
// GetFrame will call DrawSingleTile internally.
|
2014-04-15 18:02:23 +00:00
|
|
|
RefPtr<SourceSurface> surface =
|
2013-12-13 08:34:24 +00:00
|
|
|
GetFrameInternal(aViewportSize, aSVGContext, aWhichFrame, aFlags);
|
2013-04-05 21:14:32 +00:00
|
|
|
NS_ENSURE_TRUE(surface, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// Create a drawable from that surface.
|
|
|
|
nsRefPtr<gfxSurfaceDrawable> drawable =
|
|
|
|
new gfxSurfaceDrawable(surface, gfxIntSize(mClip.width, mClip.height));
|
|
|
|
|
|
|
|
// Draw.
|
|
|
|
gfxRect imageRect(0, 0, mClip.width, mClip.height);
|
|
|
|
gfxRect subimage(aSubimage.x, aSubimage.y, aSubimage.width, aSubimage.height);
|
|
|
|
gfxUtils::DrawPixelSnapped(aContext, drawable, aUserSpaceToImageSpace,
|
|
|
|
subimage, sourceRect, imageRect, aFill,
|
2014-01-23 18:26:40 +00:00
|
|
|
gfxImageFormat::ARGB32, aFilter);
|
2013-04-05 21:14:32 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Determine the appropriate subimage for the inner image.
|
|
|
|
nsIntRect innerSubimage(aSubimage);
|
|
|
|
innerSubimage.MoveBy(mClip.x, mClip.y);
|
|
|
|
innerSubimage.Intersect(mClip);
|
|
|
|
|
|
|
|
return DrawSingleTile(aContext, aFilter, aUserSpaceToImageSpace, aFill, innerSubimage,
|
|
|
|
aViewportSize, aSVGContext, aWhichFrame, aFlags);
|
|
|
|
}
|
|
|
|
|
|
|
|
gfxFloat
|
|
|
|
ClippedImage::ClampFactor(const gfxFloat aToClamp, const int aReference) const
|
|
|
|
{
|
|
|
|
return aToClamp > aReference ? aReference / aToClamp
|
|
|
|
: 1.0;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
ClippedImage::DrawSingleTile(gfxContext* aContext,
|
2013-10-01 21:01:19 +00:00
|
|
|
GraphicsFilter aFilter,
|
2013-04-05 21:14:32 +00:00
|
|
|
const gfxMatrix& aUserSpaceToImageSpace,
|
|
|
|
const gfxRect& aFill,
|
|
|
|
const nsIntRect& aSubimage,
|
|
|
|
const nsIntSize& aViewportSize,
|
|
|
|
const SVGImageContext* aSVGContext,
|
|
|
|
uint32_t aWhichFrame,
|
|
|
|
uint32_t aFlags)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(!MustCreateSurface(aContext, aUserSpaceToImageSpace,
|
|
|
|
aUserSpaceToImageSpace.Transform(aFill),
|
|
|
|
aSubimage - nsIntPoint(mClip.x, mClip.y), aFlags),
|
|
|
|
"DrawSingleTile shouldn't need to create a surface");
|
|
|
|
|
|
|
|
// Make the viewport reflect the original image's size.
|
|
|
|
nsIntSize viewportSize(aViewportSize);
|
|
|
|
int32_t imgWidth, imgHeight;
|
|
|
|
if (NS_SUCCEEDED(InnerImage()->GetWidth(&imgWidth)) &&
|
|
|
|
NS_SUCCEEDED(InnerImage()->GetHeight(&imgHeight))) {
|
|
|
|
viewportSize = nsIntSize(imgWidth, imgHeight);
|
|
|
|
} else {
|
|
|
|
MOZ_ASSERT(false, "If ShouldClip() led us to draw then we should never get here");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add a translation to the transform to reflect the clipping region.
|
|
|
|
gfxMatrix transform(aUserSpaceToImageSpace);
|
|
|
|
transform.Multiply(gfxMatrix().Translate(gfxPoint(mClip.x, mClip.y)));
|
|
|
|
|
|
|
|
// "Clamp the source rectangle" to the clipping region's width and height.
|
|
|
|
// Really, this means modifying the transform to get the results we want.
|
|
|
|
gfxRect sourceRect = transform.Transform(aFill);
|
|
|
|
if (sourceRect.width > mClip.width || sourceRect.height > mClip.height) {
|
|
|
|
gfxMatrix clampSource;
|
|
|
|
clampSource.Translate(gfxPoint(sourceRect.x, sourceRect.y));
|
|
|
|
clampSource.Scale(ClampFactor(sourceRect.width, mClip.width),
|
|
|
|
ClampFactor(sourceRect.height, mClip.height));
|
|
|
|
clampSource.Translate(gfxPoint(-sourceRect.x, -sourceRect.y));
|
|
|
|
transform.Multiply(clampSource);
|
|
|
|
}
|
|
|
|
|
|
|
|
return InnerImage()->Draw(aContext, aFilter, transform, aFill, aSubimage,
|
|
|
|
viewportSize, aSVGContext, aWhichFrame, aFlags);
|
|
|
|
}
|
|
|
|
|
2013-04-25 22:58:32 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
ClippedImage::RequestDiscard()
|
|
|
|
{
|
|
|
|
// We're very aggressive about discarding.
|
|
|
|
mCachedSurface = nullptr;
|
|
|
|
|
|
|
|
return InnerImage()->RequestDiscard();
|
|
|
|
}
|
|
|
|
|
2013-08-25 07:19:42 +00:00
|
|
|
NS_IMETHODIMP_(Orientation)
|
|
|
|
ClippedImage::GetOrientation()
|
|
|
|
{
|
|
|
|
// XXX(seth): This should not actually be here; this is just to work around a
|
|
|
|
// what appears to be a bug in MSVC's linker.
|
|
|
|
return InnerImage()->GetOrientation();
|
|
|
|
}
|
|
|
|
|
2013-04-05 21:14:32 +00:00
|
|
|
} // namespace image
|
|
|
|
} // namespace mozilla
|