void
ISurfaceAllocator::DestroySharedSurface(SurfaceDescriptor* aSurface)
{
MOZ_ASSERT(aSurface);
if (!aSurface) {
return;
}
if (!IsOnCompositorSide() && ReleaseOwnedSurfaceDescriptor(*aSurface)) {
*aSurface = SurfaceDescriptor();
return;
}
if (PlatformDestroySharedSurface(aSurface)) {
return;
}
switch (aSurface->type()) {
case SurfaceDescriptor::TShmem:
DeallocShmem(aSurface->get_Shmem());
break;
case SurfaceDescriptor::TYCbCrImage:
DeallocShmem(aSurface->get_YCbCrImage().data());
break;
case SurfaceDescriptor::TRGBImage:
DeallocShmem(aSurface->get_RGBImage().data());
break;
case SurfaceDescriptor::TSurfaceDescriptorD3D10:
break;
case SurfaceDescriptor::Tnull_t:
case SurfaceDescriptor::T__None:
break;
default:
NS_RUNTIMEABORT("surface type not implemented!");
}
*aSurface = SurfaceDescriptor();
}
void
ContentClientIncremental::Updated(const nsIntRegion& aRegionToDraw,
const nsIntRegion& aVisibleRegion,
bool aDidSelfCopy)
{
if (IsSurfaceDescriptorValid(mUpdateDescriptor)) {
mForwarder->UpdateTextureIncremental(this,
TextureFront,
mUpdateDescriptor,
aRegionToDraw,
mBufferRect,
mBufferRotation);
mUpdateDescriptor = SurfaceDescriptor();
}
if (IsSurfaceDescriptorValid(mUpdateDescriptorOnWhite)) {
mForwarder->UpdateTextureIncremental(this,
TextureOnWhiteFront,
mUpdateDescriptorOnWhite,
aRegionToDraw,
mBufferRect,
mBufferRotation);
mUpdateDescriptorOnWhite = SurfaceDescriptor();
}
}
ContentClientDoubleBuffered::~ContentClientDoubleBuffered()
{
if (mTextureClient) {
MOZ_ASSERT(mFrontClient);
mTextureClient->SetDescriptor(SurfaceDescriptor());
mFrontClient->SetDescriptor(SurfaceDescriptor());
}
}
ContentClientSingleBuffered::~ContentClientSingleBuffered()
{
if (mDeprecatedTextureClient) {
mDeprecatedTextureClient->SetDescriptor(SurfaceDescriptor());
}
if (mDeprecatedTextureClientOnWhite) {
mDeprecatedTextureClientOnWhite->SetDescriptor(SurfaceDescriptor());
}
}
ContentClientDoubleBuffered::~ContentClientDoubleBuffered()
{
if (mDeprecatedTextureClient) {
MOZ_ASSERT(mFrontClient);
mDeprecatedTextureClient->SetDescriptor(SurfaceDescriptor());
mFrontClient->SetDescriptor(SurfaceDescriptor());
}
if (mDeprecatedTextureClientOnWhite) {
MOZ_ASSERT(mFrontClientOnWhite);
mDeprecatedTextureClientOnWhite->SetDescriptor(SurfaceDescriptor());
mFrontClientOnWhite->SetDescriptor(SurfaceDescriptor());
}
}
void DestroyBackBuffer()
{
if (mBackBuffer.type() == SurfaceDescriptor::TSharedTextureDescriptor) {
SharedTextureDescriptor handle = mBackBuffer.get_SharedTextureDescriptor();
if (mGLContext && handle.handle()) {
mGLContext->ReleaseSharedHandle(handle.shareType(), handle.handle());
mBackBuffer = SurfaceDescriptor();
}
} else if (IsSurfaceDescriptorValid(mBackBuffer)) {
BasicManager()->ShadowLayerForwarder::DestroySharedSurface(&mBackBuffer);
mBackBuffer = SurfaceDescriptor();
}
}
void
ISurfaceAllocator::DestroySharedSurface(SurfaceDescriptor* aSurface)
{
MOZ_ASSERT(aSurface);
if (!aSurface) {
return;
}
if (PlatformDestroySharedSurface(aSurface)) {
return;
}
switch (aSurface->type()) {
case SurfaceDescriptor::TShmem:
DeallocShmem(aSurface->get_Shmem());
break;
case SurfaceDescriptor::TYCbCrImage:
DeallocShmem(aSurface->get_YCbCrImage().data());
break;
case SurfaceDescriptor::TRGBImage:
DeallocShmem(aSurface->get_RGBImage().data());
break;
case SurfaceDescriptor::TSurfaceDescriptorD3D9:
case SurfaceDescriptor::TSurfaceDescriptorD3D10:
break;
case SurfaceDescriptor::TMemoryImage:
delete [] (unsigned char *)aSurface->get_MemoryImage().data();
break;
case SurfaceDescriptor::Tnull_t:
case SurfaceDescriptor::T__None:
break;
default:
NS_RUNTIMEABORT("surface type not implemented!");
}
*aSurface = SurfaceDescriptor();
}
void
ImageBridgeChild::UpdateTexture(CompositableClient* aCompositable,
TextureIdentifier aTextureId,
SurfaceDescriptor* aDescriptor)
{
if (aDescriptor->type() != SurfaceDescriptor::T__None &&
aDescriptor->type() != SurfaceDescriptor::Tnull_t) {
MOZ_ASSERT(aCompositable);
MOZ_ASSERT(aCompositable->GetIPDLActor());
mTxn->AddEdit(OpPaintTexture(nullptr, aCompositable->GetIPDLActor(), 1,
SurfaceDescriptor(*aDescriptor)));
*aDescriptor = SurfaceDescriptor();
} else {
NS_WARNING("Trying to send a null SurfaceDescriptor.");
}
}
void
DeprecatedTextureHost::OnShutdown()
{
if (ISurfaceAllocator::IsShmem(mBuffer)) {
*mBuffer = SurfaceDescriptor();
mBuffer = nullptr;
}
}
void
TextureClientShmem::ReleaseResources()
{
if (mSurface) {
mSurface = nullptr;
ShadowLayerForwarder::CloseDescriptor(mDescriptor);
}
if (mTextureInfo.mTextureFlags & HostRelease) {
mDescriptor = SurfaceDescriptor();
return;
}
if (IsSurfaceDescriptorValid(mDescriptor)) {
mForwarder->DestroySharedSurface(&mDescriptor);
mDescriptor = SurfaceDescriptor();
}
}
static bool
TakeAndDestroyXlibSurface(SurfaceDescriptor* aSurface)
{
nsRefPtr<gfxXlibSurface> surf =
aSurface->get_SurfaceDescriptorX11().OpenForeign();
surf->TakePixmap();
*aSurface = SurfaceDescriptor();
// the Pixmap is destroyed when |surf| goes out of scope
return true;
}
void
DeprecatedTextureClientShmem::ReleaseResources()
{
if (mSurface) {
mSurface = nullptr;
mSurfaceAsImage = nullptr;
ShadowLayerForwarder::CloseDescriptor(mDescriptor);
}
if (!(mTextureInfo.mTextureFlags & TEXTURE_DEALLOCATE_CLIENT)) {
mDescriptor = SurfaceDescriptor();
return;
}
if (IsSurfaceDescriptorValid(mDescriptor)) {
mForwarder->DestroySharedSurface(&mDescriptor);
mDescriptor = SurfaceDescriptor();
}
}
void
TextureClientSharedOGL::ReleaseResources()
{
if (!IsSurfaceDescriptorValid(mDescriptor)) {
return;
}
MOZ_ASSERT(mDescriptor.type() == SurfaceDescriptor::TSharedTextureDescriptor);
mDescriptor = SurfaceDescriptor();
// It's important our handle gets released! SharedTextureHostOGL will take
// care of this for us though.
}
void
DeprecatedTextureClientShmemYCbCr::SetDescriptorFromReply(const SurfaceDescriptor& aDescriptor)
{
MOZ_ASSERT(aDescriptor.type() == SurfaceDescriptor::TYCbCrImage);
DeprecatedSharedPlanarYCbCrImage* shYCbCr = DeprecatedSharedPlanarYCbCrImage::FromSurfaceDescriptor(aDescriptor);
if (shYCbCr) {
shYCbCr->Release();
mDescriptor = SurfaceDescriptor();
} else {
SetDescriptor(aDescriptor);
}
}
/*static*/ bool
ShadowLayerForwarder::PlatformDestroySharedSurface(SurfaceDescriptor* aSurface)
{
if (SurfaceDescriptor::TSurfaceDescriptorGralloc != aSurface->type()) {
return false;
}
PGrallocBufferChild* gbp =
aSurface->get_SurfaceDescriptorGralloc().bufferChild();
PGrallocBufferChild::Send__delete__(gbp);
*aSurface = SurfaceDescriptor();
return true;
}
bool
ShadowLayerManager::PlatformDestroySharedSurface(SurfaceDescriptor* aSurface)
{
if (SurfaceDescriptor::TSurfaceDescriptorGralloc != aSurface->type()) {
return false;
}
PGrallocBufferParent* gbp =
aSurface->get_SurfaceDescriptorGralloc().bufferParent();
unused << PGrallocBufferParent::Send__delete__(gbp);
*aSurface = SurfaceDescriptor();
return true;
}
static void
DestroySharedShmemSurface(SurfaceDescriptor* aSurface,
ShmemDeallocator* aDeallocator)
{
switch (aSurface->type()) {
case SurfaceDescriptor::TShmem: {
aDeallocator->DeallocShmem(aSurface->get_Shmem());
*aSurface = SurfaceDescriptor();
return;
}
default:
NS_RUNTIMEABORT("unexpected SurfaceDescriptor type!");
return;
}
}
bool
ISurfaceAllocator::PlatformDestroySharedSurface(SurfaceDescriptor* aSurface)
{
if (SurfaceDescriptor::TSurfaceDescriptorGralloc != aSurface->type()) {
return false;
}
// we should have either a bufferParent or bufferChild
// depending on whether we're on the parent or child side.
PGrallocBufferParent* gbp =
aSurface->get_SurfaceDescriptorGralloc().bufferParent();
if (gbp) {
unused << PGrallocBufferParent::Send__delete__(gbp);
} else {
PGrallocBufferChild* gbc =
aSurface->get_SurfaceDescriptorGralloc().bufferChild();
unused << PGrallocBufferChild::Send__delete__(gbc);
}
*aSurface = SurfaceDescriptor();
return true;
}
bool
ShadowLayersParent::RecvUpdate(const InfallibleTArray<Edit>& cset,
InfallibleTArray<EditReply>* reply)
{
MOZ_LAYERS_LOG(("[ParentSide] received txn with %d edits", cset.Length()));
if (mDestroyed || layer_manager()->IsDestroyed()) {
return true;
}
EditReplyVector replyv;
layer_manager()->BeginTransactionWithTarget(NULL);
for (EditArray::index_type i = 0; i < cset.Length(); ++i) {
const Edit& edit = cset[i];
switch (edit.type()) {
// Create* ops
case Edit::TOpCreateThebesLayer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateThebesLayer"));
nsRefPtr<ShadowThebesLayer> layer =
layer_manager()->CreateShadowThebesLayer();
layer->SetAllocator(this);
AsShadowLayer(edit.get_OpCreateThebesLayer())->Bind(layer);
break;
}
case Edit::TOpCreateContainerLayer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateContainerLayer"));
nsRefPtr<ContainerLayer> layer = layer_manager()->CreateShadowContainerLayer();
AsShadowLayer(edit.get_OpCreateContainerLayer())->Bind(layer);
break;
}
case Edit::TOpCreateImageLayer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateImageLayer"));
nsRefPtr<ShadowImageLayer> layer =
layer_manager()->CreateShadowImageLayer();
layer->SetAllocator(this);
AsShadowLayer(edit.get_OpCreateImageLayer())->Bind(layer);
break;
}
case Edit::TOpCreateColorLayer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateColorLayer"));
nsRefPtr<ShadowColorLayer> layer = layer_manager()->CreateShadowColorLayer();
AsShadowLayer(edit.get_OpCreateColorLayer())->Bind(layer);
break;
}
case Edit::TOpCreateCanvasLayer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateCanvasLayer"));
nsRefPtr<ShadowCanvasLayer> layer =
layer_manager()->CreateShadowCanvasLayer();
layer->SetAllocator(this);
AsShadowLayer(edit.get_OpCreateCanvasLayer())->Bind(layer);
break;
}
case Edit::TOpCreateThebesBuffer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateThebesBuffer"));
const OpCreateThebesBuffer& otb = edit.get_OpCreateThebesBuffer();
ShadowThebesLayer* thebes = static_cast<ShadowThebesLayer*>(
AsShadowLayer(otb)->AsLayer());
thebes->SetFrontBuffer(otb.initialFront(), otb.frontValidRegion());
break;
}
case Edit::TOpCreateCanvasBuffer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateCanvasBuffer"));
const OpCreateCanvasBuffer& ocb = edit.get_OpCreateCanvasBuffer();
ShadowCanvasLayer* canvas = static_cast<ShadowCanvasLayer*>(
AsShadowLayer(ocb)->AsLayer());
canvas->Init(ocb.initialFront(), ocb.size(), ocb.needYFlip());
break;
}
case Edit::TOpCreateImageBuffer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateImageBuffer"));
const OpCreateImageBuffer ocb = edit.get_OpCreateImageBuffer();
ShadowImageLayer* image = static_cast<ShadowImageLayer*>(
AsShadowLayer(ocb)->AsLayer());
image->Init(ocb.initialFront(), ocb.size());
break;
}
case Edit::TOpDestroyThebesFrontBuffer: {
MOZ_LAYERS_LOG(("[ParentSide] DestroyThebesFrontBuffer"));
const OpDestroyThebesFrontBuffer& odfb =
edit.get_OpDestroyThebesFrontBuffer();
ShadowThebesLayer* thebes = static_cast<ShadowThebesLayer*>(
AsShadowLayer(odfb)->AsLayer());
thebes->DestroyFrontBuffer();
break;
}
case Edit::TOpDestroyCanvasFrontBuffer: {
MOZ_LAYERS_LOG(("[ParentSide] DestroyCanvasFrontBuffer"));
const OpDestroyCanvasFrontBuffer& odfb =
edit.get_OpDestroyCanvasFrontBuffer();
ShadowCanvasLayer* canvas = static_cast<ShadowCanvasLayer*>(
AsShadowLayer(odfb)->AsLayer());
canvas->DestroyFrontBuffer();
break;
}
case Edit::TOpDestroyImageFrontBuffer: {
MOZ_LAYERS_LOG(("[ParentSide] DestroyImageFrontBuffer"));
const OpDestroyImageFrontBuffer& odfb =
edit.get_OpDestroyImageFrontBuffer();
ShadowImageLayer* image = static_cast<ShadowImageLayer*>(
AsShadowLayer(odfb)->AsLayer());
image->DestroyFrontBuffer();
break;
}
// Attributes
case Edit::TOpSetLayerAttributes: {
MOZ_LAYERS_LOG(("[ParentSide] SetLayerAttributes"));
const OpSetLayerAttributes& osla = edit.get_OpSetLayerAttributes();
Layer* layer = AsShadowLayer(osla)->AsLayer();
const LayerAttributes& attrs = osla.attrs();
const CommonLayerAttributes& common = attrs.common();
layer->SetVisibleRegion(common.visibleRegion());
layer->SetContentFlags(common.contentFlags());
layer->SetOpacity(common.opacity());
layer->SetClipRect(common.useClipRect() ? &common.clipRect() : NULL);
layer->SetTransform(common.transform());
layer->SetTileSourceRect(common.useTileSourceRect() ? &common.tileSourceRect() : NULL);
static bool fixedPositionLayersEnabled = getenv("MOZ_ENABLE_FIXED_POSITION_LAYERS") != 0;
if (fixedPositionLayersEnabled) {
layer->SetIsFixedPosition(common.isFixedPosition());
}
typedef SpecificLayerAttributes Specific;
const SpecificLayerAttributes& specific = attrs.specific();
switch (specific.type()) {
case Specific::Tnull_t:
break;
case Specific::TThebesLayerAttributes: {
MOZ_LAYERS_LOG(("[ParentSide] thebes layer"));
ShadowThebesLayer* thebesLayer =
static_cast<ShadowThebesLayer*>(layer);
const ThebesLayerAttributes& attrs =
specific.get_ThebesLayerAttributes();
thebesLayer->SetValidRegion(attrs.validRegion());
break;
}
case Specific::TContainerLayerAttributes:
MOZ_LAYERS_LOG(("[ParentSide] container layer"));
static_cast<ContainerLayer*>(layer)->SetFrameMetrics(
specific.get_ContainerLayerAttributes().metrics());
break;
case Specific::TColorLayerAttributes:
MOZ_LAYERS_LOG(("[ParentSide] color layer"));
static_cast<ColorLayer*>(layer)->SetColor(
specific.get_ColorLayerAttributes().color());
break;
case Specific::TCanvasLayerAttributes:
MOZ_LAYERS_LOG(("[ParentSide] canvas layer"));
static_cast<CanvasLayer*>(layer)->SetFilter(
specific.get_CanvasLayerAttributes().filter());
break;
case Specific::TImageLayerAttributes:
MOZ_LAYERS_LOG(("[ParentSide] image layer"));
static_cast<ImageLayer*>(layer)->SetFilter(
specific.get_ImageLayerAttributes().filter());
break;
default:
NS_RUNTIMEABORT("not reached");
}
break;
}
// Tree ops
case Edit::TOpSetRoot: {
MOZ_LAYERS_LOG(("[ParentSide] SetRoot"));
mRoot = AsShadowLayer(edit.get_OpSetRoot())->AsContainer();
break;
}
case Edit::TOpInsertAfter: {
MOZ_LAYERS_LOG(("[ParentSide] InsertAfter"));
const OpInsertAfter& oia = edit.get_OpInsertAfter();
ShadowContainer(oia)->AsContainer()->InsertAfter(
ShadowChild(oia)->AsLayer(), ShadowAfter(oia)->AsLayer());
break;
}
case Edit::TOpAppendChild: {
MOZ_LAYERS_LOG(("[ParentSide] AppendChild"));
const OpAppendChild& oac = edit.get_OpAppendChild();
ShadowContainer(oac)->AsContainer()->InsertAfter(
ShadowChild(oac)->AsLayer(), NULL);
break;
}
case Edit::TOpRemoveChild: {
MOZ_LAYERS_LOG(("[ParentSide] RemoveChild"));
const OpRemoveChild& orc = edit.get_OpRemoveChild();
Layer* childLayer = ShadowChild(orc)->AsLayer();
ShadowContainer(orc)->AsContainer()->RemoveChild(childLayer);
break;
}
case Edit::TOpPaintThebesBuffer: {
MOZ_LAYERS_LOG(("[ParentSide] Paint ThebesLayer"));
const OpPaintThebesBuffer& op = edit.get_OpPaintThebesBuffer();
ShadowLayerParent* shadow = AsShadowLayer(op);
ShadowThebesLayer* thebes =
static_cast<ShadowThebesLayer*>(shadow->AsLayer());
const ThebesBuffer& newFront = op.newFrontBuffer();
ThebesBuffer newBack;
nsIntRegion newValidRegion;
OptionalThebesBuffer readonlyFront;
nsIntRegion frontUpdatedRegion;
thebes->Swap(newFront, op.updatedRegion(),
&newBack, &newValidRegion,
&readonlyFront, &frontUpdatedRegion);
replyv.push_back(
OpThebesBufferSwap(
shadow, NULL,
newBack, newValidRegion,
readonlyFront, frontUpdatedRegion));
break;
}
case Edit::TOpPaintCanvas: {
MOZ_LAYERS_LOG(("[ParentSide] Paint CanvasLayer"));
const OpPaintCanvas& op = edit.get_OpPaintCanvas();
ShadowLayerParent* shadow = AsShadowLayer(op);
ShadowCanvasLayer* canvas =
static_cast<ShadowCanvasLayer*>(shadow->AsLayer());
SurfaceDescriptor newFront = op.newFrontBuffer();
SurfaceDescriptor newBack;
canvas->Swap(op.newFrontBuffer(), &newBack);
if (newFront == newBack) {
newFront = SurfaceDescriptor();
}
canvas->Updated();
replyv.push_back(OpBufferSwap(shadow, NULL,
newBack));
break;
}
case Edit::TOpPaintImage: {
MOZ_LAYERS_LOG(("[ParentSide] Paint ImageLayer"));
const OpPaintImage& op = edit.get_OpPaintImage();
ShadowLayerParent* shadow = AsShadowLayer(op);
ShadowImageLayer* image =
static_cast<ShadowImageLayer*>(shadow->AsLayer());
SharedImage newFront = op.newFrontBuffer();
SharedImage newBack;
image->Swap(op.newFrontBuffer(), &newBack);
if (newFront == newBack) {
newFront = SharedImage();
}
replyv.push_back(OpImageSwap(shadow, NULL,
newBack));
break;
}
default:
NS_RUNTIMEABORT("not reached");
}
}
layer_manager()->EndTransaction(NULL, NULL);
reply->SetCapacity(replyv.size());
if (replyv.size() > 0) {
reply->AppendElements(&replyv.front(), replyv.size());
}
// Ensure that any pending operations involving back and front
// buffers have completed, so that neither process stomps on the
// other's buffer contents.
ShadowLayerManager::PlatformSyncBeforeReplyUpdate();
Frame()->ShadowLayersUpdated();
return true;
}
ContentClientSingleBuffered::~ContentClientSingleBuffered()
{
if (mTextureClient) {
mTextureClient->SetDescriptor(SurfaceDescriptor());
}
}
virtual void Disconnect()
{
mBackBuffer = SurfaceDescriptor();
BasicShadowableLayer::Disconnect();
}
DeprecatedTextureClientD3D11::~DeprecatedTextureClientD3D11()
{
mDescriptor = SurfaceDescriptor();
ClearDT();
}
void
BasicShadowableCanvasLayer::Paint(gfxContext* aContext, Layer* aMaskLayer)
{
if (!HasShadow()) {
BasicCanvasLayer::Paint(aContext, aMaskLayer);
return;
}
if (!IsDirty())
return;
if (mGLContext &&
!mForceReadback &&
BasicManager()->GetParentBackendType() == mozilla::layers::LAYERS_OPENGL) {
TextureImage::TextureShareType flags;
// if process type is default, then it is single-process (non-e10s)
if (XRE_GetProcessType() == GeckoProcessType_Default)
flags = TextureImage::ThreadShared;
else
flags = TextureImage::ProcessShared;
SharedTextureHandle handle = GetSharedBackBufferHandle();
if (!handle) {
handle = mGLContext->CreateSharedHandle(flags);
if (handle) {
mBackBuffer = SharedTextureDescriptor(flags, handle, mBounds.Size(), false);
}
}
if (handle) {
mGLContext->MakeCurrent();
mGLContext->UpdateSharedHandle(flags, handle);
// call Painted() to reset our dirty 'bit'
Painted();
FireDidTransactionCallback();
BasicManager()->PaintedCanvas(BasicManager()->Hold(this),
mNeedsYFlip,
mBackBuffer);
// Move SharedTextureHandle ownership to ShadowLayer
mBackBuffer = SurfaceDescriptor();
return;
}
}
bool isOpaque = (GetContentFlags() & CONTENT_OPAQUE);
if (!IsSurfaceDescriptorValid(mBackBuffer) ||
isOpaque != mBufferIsOpaque) {
DestroyBackBuffer();
mBufferIsOpaque = isOpaque;
gfxIntSize size(mBounds.width, mBounds.height);
gfxASurface::gfxContentType type = isOpaque ?
gfxASurface::CONTENT_COLOR : gfxASurface::CONTENT_COLOR_ALPHA;
if (!BasicManager()->AllocBuffer(size, type, &mBackBuffer)) {
NS_RUNTIMEABORT("creating CanvasLayer back buffer failed!");
}
}
AutoOpenSurface autoBackSurface(OPEN_READ_WRITE, mBackBuffer);
if (aMaskLayer) {
static_cast<BasicImplData*>(aMaskLayer->ImplData())
->Paint(aContext, nullptr);
}
UpdateSurface(autoBackSurface.Get(), nullptr);
FireDidTransactionCallback();
BasicManager()->PaintedCanvas(BasicManager()->Hold(this),
mNeedsYFlip, mBackBuffer);
}
bool
DeprecatedImageClientSingle::UpdateImage(ImageContainer* aContainer,
uint32_t aContentFlags)
{
AutoLockImage autoLock(aContainer);
Image *image = autoLock.GetImage();
if (!image) {
return false;
}
if (mLastPaintedImageSerial == image->GetSerial()) {
return true;
}
if (image->GetFormat() == PLANAR_YCBCR &&
EnsureDeprecatedTextureClient(TEXTURE_YCBCR)) {
PlanarYCbCrImage* ycbcr = static_cast<PlanarYCbCrImage*>(image);
if (ycbcr->AsDeprecatedSharedPlanarYCbCrImage()) {
AutoLockDeprecatedTextureClient lock(mDeprecatedTextureClient);
SurfaceDescriptor sd;
if (!ycbcr->AsDeprecatedSharedPlanarYCbCrImage()->ToSurfaceDescriptor(sd)) {
return false;
}
if (IsSurfaceDescriptorValid(*lock.GetSurfaceDescriptor())) {
GetForwarder()->DestroySharedSurface(lock.GetSurfaceDescriptor());
}
*lock.GetSurfaceDescriptor() = sd;
} else {
AutoLockYCbCrClient clientLock(mDeprecatedTextureClient);
if (!clientLock.Update(ycbcr)) {
NS_WARNING("failed to update DeprecatedTextureClient (YCbCr)");
return false;
}
}
} else if (image->GetFormat() == SHARED_TEXTURE &&
EnsureDeprecatedTextureClient(TEXTURE_SHARED_GL_EXTERNAL)) {
SharedTextureImage* sharedImage = static_cast<SharedTextureImage*>(image);
const SharedTextureImage::Data *data = sharedImage->GetData();
SharedTextureDescriptor texture(data->mShareType,
data->mHandle,
data->mSize,
data->mInverted);
mDeprecatedTextureClient->SetDescriptor(SurfaceDescriptor(texture));
} else if (image->GetFormat() == SHARED_RGB &&
EnsureDeprecatedTextureClient(TEXTURE_SHMEM)) {
nsIntRect rect(0, 0,
image->GetSize().width,
image->GetSize().height);
UpdatePictureRect(rect);
AutoLockDeprecatedTextureClient lock(mDeprecatedTextureClient);
SurfaceDescriptor desc;
if (!static_cast<DeprecatedSharedRGBImage*>(image)->ToSurfaceDescriptor(desc)) {
return false;
}
mDeprecatedTextureClient->SetDescriptor(desc);
#ifdef MOZ_WIDGET_GONK
} else if (image->GetFormat() == GONK_IO_SURFACE &&
EnsureDeprecatedTextureClient(TEXTURE_SHARED_GL_EXTERNAL)) {
nsIntRect rect(0, 0,
image->GetSize().width,
image->GetSize().height);
UpdatePictureRect(rect);
AutoLockDeprecatedTextureClient lock(mDeprecatedTextureClient);
SurfaceDescriptor desc = static_cast<GonkIOSurfaceImage*>(image)->GetSurfaceDescriptor();
if (!IsSurfaceDescriptorValid(desc)) {
return false;
}
mDeprecatedTextureClient->SetDescriptor(desc);
} else if (image->GetFormat() == GRALLOC_PLANAR_YCBCR) {
EnsureDeprecatedTextureClient(TEXTURE_SHARED_GL_EXTERNAL);
nsIntRect rect(0, 0,
image->GetSize().width,
image->GetSize().height);
UpdatePictureRect(rect);
AutoLockDeprecatedTextureClient lock(mDeprecatedTextureClient);
SurfaceDescriptor desc = static_cast<GrallocPlanarYCbCrImage*>(image)->GetSurfaceDescriptor();
if (!IsSurfaceDescriptorValid(desc)) {
return false;
}
mDeprecatedTextureClient->SetDescriptor(desc);
#endif
} else {
nsRefPtr<gfxASurface> surface = image->GetAsSurface();
MOZ_ASSERT(surface);
EnsureDeprecatedTextureClient(TEXTURE_SHMEM);
MOZ_ASSERT(mDeprecatedTextureClient, "Failed to create texture client");
AutoLockShmemClient clientLock(mDeprecatedTextureClient);
if (!clientLock.Update(image, aContentFlags, surface)) {
NS_WARNING("failed to update DeprecatedTextureClient");
return false;
}
}
Updated();
if (image->GetFormat() == PLANAR_YCBCR) {
PlanarYCbCrImage* ycbcr = static_cast<PlanarYCbCrImage*>(image);
UpdatePictureRect(ycbcr->GetData()->GetPictureRect());
}
mLastPaintedImageSerial = image->GetSerial();
aContainer->NotifyPaintedImage(image);
return true;
}
bool
ImageClientSingle::UpdateImage(ImageContainer* aContainer,
uint32_t aContentFlags)
{
AutoLockImage autoLock(aContainer);
Image *image = autoLock.GetImage();
if (!image) {
return false;
}
if (mLastPaintedImageSerial == image->GetSerial()) {
return true;
}
if (image->GetFormat() == PLANAR_YCBCR) {
EnsureTextureClient(TEXTURE_YCBCR);
PlanarYCbCrImage* ycbcr = static_cast<PlanarYCbCrImage*>(image);
if (ycbcr->AsSharedPlanarYCbCrImage()) {
AutoLockTextureClient lock(mTextureClient);
SurfaceDescriptor sd;
if (!ycbcr->AsSharedPlanarYCbCrImage()->ToSurfaceDescriptor(sd)) {
return false;
}
if (IsSurfaceDescriptorValid(*lock.GetSurfaceDescriptor())) {
GetForwarder()->DestroySharedSurface(lock.GetSurfaceDescriptor());
}
*lock.GetSurfaceDescriptor() = sd;
} else {
AutoLockYCbCrClient clientLock(mTextureClient);
if (!clientLock.Update(ycbcr)) {
NS_WARNING("failed to update TextureClient (YCbCr)");
return false;
}
}
} else if (image->GetFormat() == SHARED_TEXTURE) {
EnsureTextureClient(TEXTURE_SHARED_GL_EXTERNAL);
SharedTextureImage* sharedImage = static_cast<SharedTextureImage*>(image);
const SharedTextureImage::Data *data = sharedImage->GetData();
SharedTextureDescriptor texture(data->mShareType,
data->mHandle,
data->mSize,
data->mInverted);
mTextureClient->SetDescriptor(SurfaceDescriptor(texture));
} else if (image->GetFormat() == SHARED_RGB) {
EnsureTextureClient(TEXTURE_SHMEM);
nsIntRect rect(0, 0,
image->GetSize().width,
image->GetSize().height);
UpdatePictureRect(rect);
AutoLockTextureClient lock(mTextureClient);
SurfaceDescriptor desc;
if (!static_cast<SharedRGBImage*>(image)->ToSurfaceDescriptor(desc)) {
return false;
}
mTextureClient->SetDescriptor(desc);
} else {
nsRefPtr<gfxASurface> surface = image->GetAsSurface();
MOZ_ASSERT(surface);
EnsureTextureClient(TEXTURE_SHMEM);
nsRefPtr<gfxPattern> pattern = new gfxPattern(surface);
pattern->SetFilter(mFilter);
AutoLockShmemClient clientLock(mTextureClient);
if (!clientLock.Update(image, aContentFlags, pattern)) {
NS_WARNING("failed to update TextureClient");
return false;
}
}
Updated();
if (image->GetFormat() == PLANAR_YCBCR) {
PlanarYCbCrImage* ycbcr = static_cast<PlanarYCbCrImage*>(image);
UpdatePictureRect(ycbcr->GetData()->GetPictureRect());
}
mLastPaintedImageSerial = image->GetSerial();
aContainer->NotifyPaintedImage(image);
return true;
}
