зеркало из https://github.com/mozilla/gecko-dev.git
Bug 1135857 - Remove ContentClientIncremental. r=mattwoodrow
This commit is contained in:
Benoit Girard
Родитель
ca353d647a
Коммит
aa69b47387
|
|
@ -277,21 +277,6 @@ struct ParamTraits<mozilla::layers::TextureFlags>
|
|||
mozilla::layers::TextureFlags::ALL_BITS>
|
||||
{};
|
||||
|
||||
template <>
|
||||
struct ParamTraits<mozilla::layers::TextureIdentifier>
|
||||
: public ContiguousEnumSerializer<
|
||||
mozilla::layers::TextureIdentifier,
|
||||
mozilla::layers::TextureIdentifier::Front,
|
||||
mozilla::layers::TextureIdentifier::HighBound>
|
||||
{};
|
||||
|
||||
template <>
|
||||
struct ParamTraits<mozilla::layers::DeprecatedTextureHostFlags>
|
||||
: public BitFlagsEnumSerializer<
|
||||
mozilla::layers::DeprecatedTextureHostFlags,
|
||||
mozilla::layers::DeprecatedTextureHostFlags::ALL_BITS>
|
||||
{};
|
||||
|
||||
template <>
|
||||
struct ParamTraits<mozilla::layers::DiagnosticTypes>
|
||||
: public BitFlagsEnumSerializer<
|
||||
|
|
@ -834,14 +819,12 @@ struct ParamTraits<mozilla::layers::TextureInfo>
|
|||
static void Write(Message* aMsg, const paramType& aParam)
|
||||
{
|
||||
WriteParam(aMsg, aParam.mCompositableType);
|
||||
WriteParam(aMsg, aParam.mDeprecatedTextureHostFlags);
|
||||
WriteParam(aMsg, aParam.mTextureFlags);
|
||||
}
|
||||
|
||||
static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
|
||||
{
|
||||
return ReadParam(aMsg, aIter, &aResult->mCompositableType) &&
|
||||
ReadParam(aMsg, aIter, &aResult->mDeprecatedTextureHostFlags) &&
|
||||
ReadParam(aMsg, aIter, &aResult->mTextureFlags);
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -133,8 +133,6 @@ enum class EffectTypes : uint8_t {
|
|||
*/
|
||||
enum class CompositableType : uint8_t {
|
||||
UNKNOWN,
|
||||
CONTENT_INC, // painted layer interface, only sends incremental
|
||||
// updates to a texture on the compositor side.
|
||||
CONTENT_TILED, // tiled painted layer
|
||||
IMAGE, // image with single buffering
|
||||
IMAGE_OVERLAY, // image without buffer
|
||||
|
|
@ -144,19 +142,6 @@ enum class CompositableType : uint8_t {
|
|||
COUNT
|
||||
};
|
||||
|
||||
/**
|
||||
* How the texture host is used for composition,
|
||||
* XXX - Only used by ContentClientIncremental
|
||||
*/
|
||||
enum class DeprecatedTextureHostFlags : uint8_t {
|
||||
DEFAULT = 0, // The default texture host for the given SurfaceDescriptor
|
||||
TILED = 1 << 0, // A texture host that supports tiling
|
||||
COPY_PREVIOUS = 1 << 1, // Texture contents should be initialized
|
||||
// from the previous texture.
|
||||
ALL_BITS = (1 << 2) - 1
|
||||
};
|
||||
MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(DeprecatedTextureHostFlags)
|
||||
|
||||
#ifdef XP_WIN
|
||||
typedef void* SyncHandle;
|
||||
#else
|
||||
|
|
@ -194,20 +179,6 @@ struct TextureFactoryIdentifier
|
|||
{}
|
||||
};
|
||||
|
||||
/**
|
||||
* Identify a texture to a compositable. Many textures can have the same id, but
|
||||
* the id is unique for any texture owned by a particular compositable.
|
||||
* XXX - We don't really need this, it will be removed along with the incremental
|
||||
* ContentClient/Host.
|
||||
*/
|
||||
enum class TextureIdentifier : uint8_t {
|
||||
Front = 1,
|
||||
Back = 2,
|
||||
OnWhiteFront = 3,
|
||||
OnWhiteBack = 4,
|
||||
HighBound
|
||||
};
|
||||
|
||||
/**
|
||||
* Information required by the compositor from the content-side for creating or
|
||||
* using compositables and textures.
|
||||
|
|
@ -218,27 +189,22 @@ enum class TextureIdentifier : uint8_t {
|
|||
struct TextureInfo
|
||||
{
|
||||
CompositableType mCompositableType;
|
||||
// XXX - only used by ContentClientIncremental
|
||||
DeprecatedTextureHostFlags mDeprecatedTextureHostFlags;
|
||||
TextureFlags mTextureFlags;
|
||||
|
||||
TextureInfo()
|
||||
: mCompositableType(CompositableType::UNKNOWN)
|
||||
, mDeprecatedTextureHostFlags(DeprecatedTextureHostFlags::DEFAULT)
|
||||
, mTextureFlags(TextureFlags::NO_FLAGS)
|
||||
{}
|
||||
|
||||
explicit TextureInfo(CompositableType aType,
|
||||
TextureFlags aTextureFlags = TextureFlags::DEFAULT)
|
||||
: mCompositableType(aType)
|
||||
, mDeprecatedTextureHostFlags(DeprecatedTextureHostFlags::DEFAULT)
|
||||
, mTextureFlags(aTextureFlags)
|
||||
{}
|
||||
|
||||
bool operator==(const TextureInfo& aOther) const
|
||||
{
|
||||
return mCompositableType == aOther.mCompositableType &&
|
||||
mDeprecatedTextureHostFlags == aOther.mDeprecatedTextureHostFlags &&
|
||||
mTextureFlags == aOther.mTextureFlags;
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -272,7 +272,6 @@ public:
|
|||
|
||||
struct DrawIterator {
|
||||
friend class RotatedContentBuffer;
|
||||
friend class ContentClientIncremental;
|
||||
DrawIterator()
|
||||
: mCount(0)
|
||||
{}
|
||||
|
|
|
|||
|
|
@ -48,8 +48,6 @@ public:
|
|||
nsIntRegion* aDestRegion = nullptr,
|
||||
gfx::IntPoint* aSrcOffset = nullptr) MOZ_OVERRIDE
|
||||
{
|
||||
// XXX - For this to work with IncrementalContentHost we will need to support
|
||||
// the aDestRegion and aSrcOffset parameters properly;
|
||||
mSurface = aSurface;
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -587,17 +587,6 @@ ClientLayerManager::ForwardTransaction(bool aScheduleComposite)
|
|||
|
||||
break;
|
||||
}
|
||||
case EditReply::TOpTextureSwap: {
|
||||
MOZ_LAYERS_LOG(("[LayersForwarder] TextureSwap"));
|
||||
|
||||
const OpTextureSwap& ots = reply.get_OpTextureSwap();
|
||||
|
||||
CompositableClient* compositable =
|
||||
CompositableClient::FromIPDLActor(ots.compositableChild());
|
||||
MOZ_ASSERT(compositable);
|
||||
compositable->SetDescriptorFromReply(ots.textureId(), ots.image());
|
||||
break;
|
||||
}
|
||||
case EditReply::TReturnReleaseFence: {
|
||||
const ReturnReleaseFence& rep = reply.get_ReturnReleaseFence();
|
||||
FenceHandle fence = rep.fence();
|
||||
|
|
|
|||
|
|
@ -143,12 +143,6 @@ public:
|
|||
TextureFlags aTextureFlags,
|
||||
TextureAllocationFlags aAllocFlags = ALLOC_DEFAULT);
|
||||
|
||||
virtual void SetDescriptorFromReply(TextureIdentifier aTextureId,
|
||||
const SurfaceDescriptor& aDescriptor)
|
||||
{
|
||||
MOZ_CRASH("If you want to call this, you should have implemented it");
|
||||
}
|
||||
|
||||
/**
|
||||
* Establishes the connection with compositor side through IPDL
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -93,11 +93,6 @@ ContentClient::CreateContentClient(CompositableForwarder* aForwarder)
|
|||
if (useDoubleBuffering || PR_GetEnv("MOZ_FORCE_DOUBLE_BUFFERING")) {
|
||||
return new ContentClientDoubleBuffered(aForwarder);
|
||||
}
|
||||
#ifdef XP_MACOSX
|
||||
if (backend == LayersBackend::LAYERS_OPENGL) {
|
||||
return new ContentClientIncremental(aForwarder);
|
||||
}
|
||||
#endif
|
||||
return new ContentClientSingleBuffered(aForwarder);
|
||||
}
|
||||
|
||||
|
|
@ -673,362 +668,5 @@ ContentClientSingleBuffered::FinalizeFrame(const nsIntRegion& aRegionToDraw)
|
|||
}
|
||||
}
|
||||
|
||||
static void
|
||||
WrapRotationAxis(int32_t* aRotationPoint, int32_t aSize)
|
||||
{
|
||||
if (*aRotationPoint < 0) {
|
||||
*aRotationPoint += aSize;
|
||||
} else if (*aRotationPoint >= aSize) {
|
||||
*aRotationPoint -= aSize;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
FillSurface(DrawTarget* aDT, const nsIntRegion& aRegion,
|
||||
const nsIntPoint& aOffset, const gfxRGBA& aColor)
|
||||
{
|
||||
nsIntRegionRectIterator iter(aRegion);
|
||||
const nsIntRect* r;
|
||||
while ((r = iter.Next()) != nullptr) {
|
||||
aDT->FillRect(Rect(r->x - aOffset.x, r->y - aOffset.y,
|
||||
r->width, r->height),
|
||||
ColorPattern(ToColor(aColor)));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ContentClientIncremental::NotifyBufferCreated(ContentType aType, TextureFlags aFlags)
|
||||
{
|
||||
mTextureInfo.mTextureFlags = aFlags;
|
||||
mContentType = aType;
|
||||
|
||||
mForwarder->CreatedIncrementalBuffer(this,
|
||||
mTextureInfo,
|
||||
mBufferRect);
|
||||
|
||||
}
|
||||
|
||||
RotatedContentBuffer::PaintState
|
||||
ContentClientIncremental::BeginPaintBuffer(PaintedLayer* aLayer,
|
||||
uint32_t aFlags)
|
||||
{
|
||||
mTextureInfo.mDeprecatedTextureHostFlags = DeprecatedTextureHostFlags::DEFAULT;
|
||||
PaintState result;
|
||||
// We need to disable rotation if we're going to be resampled when
|
||||
// drawing, because we might sample across the rotation boundary.
|
||||
bool canHaveRotation = !(aFlags & RotatedContentBuffer::PAINT_WILL_RESAMPLE);
|
||||
|
||||
nsIntRegion validRegion = aLayer->GetValidRegion();
|
||||
|
||||
bool canUseOpaqueSurface = aLayer->CanUseOpaqueSurface();
|
||||
ContentType contentType =
|
||||
canUseOpaqueSurface ? gfxContentType::COLOR :
|
||||
gfxContentType::COLOR_ALPHA;
|
||||
|
||||
SurfaceMode mode;
|
||||
nsIntRegion neededRegion;
|
||||
bool canReuseBuffer;
|
||||
nsIntRect destBufferRect;
|
||||
|
||||
while (true) {
|
||||
mode = aLayer->GetSurfaceMode();
|
||||
neededRegion = aLayer->GetVisibleRegion();
|
||||
// If we're going to resample, we need a buffer that's in clamp mode.
|
||||
canReuseBuffer = neededRegion.GetBounds().Size() <= mBufferRect.Size() &&
|
||||
mHasBuffer && !(aFlags & RotatedContentBuffer::PAINT_WILL_RESAMPLE);
|
||||
|
||||
if (canReuseBuffer) {
|
||||
if (mBufferRect.Contains(neededRegion.GetBounds())) {
|
||||
// We don't need to adjust mBufferRect.
|
||||
destBufferRect = mBufferRect;
|
||||
} else {
|
||||
// The buffer's big enough but doesn't contain everything that's
|
||||
// going to be visible. We'll move it.
|
||||
destBufferRect = nsIntRect(neededRegion.GetBounds().TopLeft(), mBufferRect.Size());
|
||||
}
|
||||
} else {
|
||||
destBufferRect = neededRegion.GetBounds();
|
||||
}
|
||||
|
||||
if (mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
|
||||
if (!gfxPrefs::ComponentAlphaEnabled() ||
|
||||
!aLayer->GetParent() ||
|
||||
!aLayer->GetParent()->SupportsComponentAlphaChildren()) {
|
||||
mode = SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA;
|
||||
} else {
|
||||
contentType = gfxContentType::COLOR;
|
||||
}
|
||||
}
|
||||
|
||||
if ((aFlags & RotatedContentBuffer::PAINT_WILL_RESAMPLE) &&
|
||||
(!neededRegion.GetBounds().IsEqualInterior(destBufferRect) ||
|
||||
neededRegion.GetNumRects() > 1)) {
|
||||
// The area we add to neededRegion might not be painted opaquely
|
||||
if (mode == SurfaceMode::SURFACE_OPAQUE) {
|
||||
contentType = gfxContentType::COLOR_ALPHA;
|
||||
mode = SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA;
|
||||
}
|
||||
// For component alpha layers, we leave contentType as gfxContentType::COLOR.
|
||||
|
||||
// We need to validate the entire buffer, to make sure that only valid
|
||||
// pixels are sampled
|
||||
neededRegion = destBufferRect;
|
||||
}
|
||||
|
||||
if (mHasBuffer &&
|
||||
(mContentType != contentType ||
|
||||
(mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) != mHasBufferOnWhite)) {
|
||||
#ifdef MOZ_DUMP_PAINTING
|
||||
if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
|
||||
if (mContentType != contentType) {
|
||||
printf_stderr("Layer's content type has changed\n");
|
||||
}
|
||||
if ((mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) != mHasBufferOnWhite) {
|
||||
printf_stderr("Layer's component alpha status has changed\n");
|
||||
}
|
||||
printf_stderr("Invalidating entire layer %p: no buffer, or content type or component alpha changed\n", aLayer);
|
||||
}
|
||||
#endif
|
||||
// We're effectively clearing the valid region, so we need to draw
|
||||
// the entire needed region now.
|
||||
result.mRegionToInvalidate = aLayer->GetValidRegion();
|
||||
validRegion.SetEmpty();
|
||||
mHasBuffer = false;
|
||||
mHasBufferOnWhite = false;
|
||||
mBufferRect.SetRect(0, 0, 0, 0);
|
||||
mBufferRotation.MoveTo(0, 0);
|
||||
// Restart decision process with the cleared buffer. We can only go
|
||||
// around the loop one more iteration, since mTexImage is null now.
|
||||
continue;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
result.mRegionToDraw.Sub(neededRegion, validRegion);
|
||||
if (result.mRegionToDraw.IsEmpty())
|
||||
return result;
|
||||
|
||||
if (destBufferRect.width > mForwarder->GetMaxTextureSize() ||
|
||||
destBufferRect.height > mForwarder->GetMaxTextureSize()) {
|
||||
return result;
|
||||
}
|
||||
|
||||
// BlitTextureImage depends on the FBO texture target being
|
||||
// TEXTURE_2D. This isn't the case on some older X1600-era Radeons.
|
||||
if (!mForwarder->SupportsTextureBlitting() ||
|
||||
!mForwarder->SupportsPartialUploads()) {
|
||||
result.mRegionToDraw = neededRegion;
|
||||
validRegion.SetEmpty();
|
||||
mHasBuffer = false;
|
||||
mHasBufferOnWhite = false;
|
||||
mBufferRect.SetRect(0, 0, 0, 0);
|
||||
mBufferRotation.MoveTo(0, 0);
|
||||
canReuseBuffer = false;
|
||||
}
|
||||
|
||||
nsIntRect drawBounds = result.mRegionToDraw.GetBounds();
|
||||
bool createdBuffer = false;
|
||||
|
||||
TextureFlags bufferFlags = TextureFlags::NO_FLAGS;
|
||||
if (mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
|
||||
bufferFlags |= TextureFlags::COMPONENT_ALPHA;
|
||||
}
|
||||
if (canReuseBuffer) {
|
||||
nsIntRect keepArea;
|
||||
if (keepArea.IntersectRect(destBufferRect, mBufferRect)) {
|
||||
// Set mBufferRotation so that the pixels currently in mBuffer
|
||||
// will still be rendered in the right place when mBufferRect
|
||||
// changes to destBufferRect.
|
||||
nsIntPoint newRotation = mBufferRotation +
|
||||
(destBufferRect.TopLeft() - mBufferRect.TopLeft());
|
||||
WrapRotationAxis(&newRotation.x, mBufferRect.width);
|
||||
WrapRotationAxis(&newRotation.y, mBufferRect.height);
|
||||
NS_ASSERTION(nsIntRect(nsIntPoint(0,0), mBufferRect.Size()).Contains(newRotation),
|
||||
"newRotation out of bounds");
|
||||
int32_t xBoundary = destBufferRect.XMost() - newRotation.x;
|
||||
int32_t yBoundary = destBufferRect.YMost() - newRotation.y;
|
||||
if ((drawBounds.x < xBoundary && xBoundary < drawBounds.XMost()) ||
|
||||
(drawBounds.y < yBoundary && yBoundary < drawBounds.YMost()) ||
|
||||
(newRotation != nsIntPoint(0,0) && !canHaveRotation)) {
|
||||
// The stuff we need to redraw will wrap around an edge of the
|
||||
// buffer, so we will need to do a self-copy
|
||||
// If mBufferRotation == nsIntPoint(0,0) we could do a real
|
||||
// self-copy but we're not going to do that in GL yet.
|
||||
// We can't do a real self-copy because the buffer is rotated.
|
||||
// So allocate a new buffer for the destination.
|
||||
destBufferRect = neededRegion.GetBounds();
|
||||
createdBuffer = true;
|
||||
} else {
|
||||
mBufferRect = destBufferRect;
|
||||
mBufferRotation = newRotation;
|
||||
}
|
||||
} else {
|
||||
// No pixels are going to be kept. The whole visible region
|
||||
// will be redrawn, so we don't need to copy anything, so we don't
|
||||
// set destBuffer.
|
||||
mBufferRect = destBufferRect;
|
||||
mBufferRotation = nsIntPoint(0,0);
|
||||
}
|
||||
} else {
|
||||
// The buffer's not big enough, so allocate a new one
|
||||
createdBuffer = true;
|
||||
}
|
||||
NS_ASSERTION(!(aFlags & RotatedContentBuffer::PAINT_WILL_RESAMPLE) ||
|
||||
destBufferRect == neededRegion.GetBounds(),
|
||||
"If we're resampling, we need to validate the entire buffer");
|
||||
|
||||
if (!createdBuffer && !mHasBuffer) {
|
||||
return result;
|
||||
}
|
||||
|
||||
if (createdBuffer) {
|
||||
if (mHasBuffer &&
|
||||
(mode != SurfaceMode::SURFACE_COMPONENT_ALPHA || mHasBufferOnWhite)) {
|
||||
mTextureInfo.mDeprecatedTextureHostFlags = DeprecatedTextureHostFlags::COPY_PREVIOUS;
|
||||
}
|
||||
|
||||
mHasBuffer = true;
|
||||
if (mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
|
||||
mHasBufferOnWhite = true;
|
||||
}
|
||||
mBufferRect = destBufferRect;
|
||||
mBufferRotation = nsIntPoint(0,0);
|
||||
NotifyBufferCreated(contentType, bufferFlags);
|
||||
}
|
||||
|
||||
NS_ASSERTION(canHaveRotation || mBufferRotation == nsIntPoint(0,0),
|
||||
"Rotation disabled, but we have nonzero rotation?");
|
||||
|
||||
nsIntRegion invalidate;
|
||||
invalidate.Sub(aLayer->GetValidRegion(), destBufferRect);
|
||||
result.mRegionToInvalidate.Or(result.mRegionToInvalidate, invalidate);
|
||||
|
||||
// If we do partial updates, we have to clip drawing to the regionToDraw.
|
||||
// If we don't clip, background images will be fillrect'd to the region correctly,
|
||||
// while text or lines will paint outside of the regionToDraw. This becomes apparent
|
||||
// with concave regions. Right now the scrollbars invalidate a narrow strip of the bar
|
||||
// although they never cover it. This leads to two draw rects, the narow strip and the actually
|
||||
// newly exposed area. It would be wise to fix this glitch in any way to have simpler
|
||||
// clip and draw regions.
|
||||
result.mClip = DrawRegionClip::DRAW;
|
||||
result.mMode = mode;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
DrawTarget*
|
||||
ContentClientIncremental::BorrowDrawTargetForPainting(PaintState& aPaintState,
|
||||
RotatedContentBuffer::DrawIterator* aIter)
|
||||
{
|
||||
if (aPaintState.mMode == SurfaceMode::SURFACE_NONE) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (aIter) {
|
||||
if (aIter->mCount++ > 0) {
|
||||
return nullptr;
|
||||
}
|
||||
aIter->mDrawRegion = aPaintState.mRegionToDraw;
|
||||
}
|
||||
|
||||
DrawTarget* result = nullptr;
|
||||
|
||||
nsIntRect drawBounds = aPaintState.mRegionToDraw.GetBounds();
|
||||
MOZ_ASSERT(!mLoanedDrawTarget);
|
||||
|
||||
// BeginUpdate is allowed to modify the given region,
|
||||
// if it wants more to be repainted than we request.
|
||||
if (aPaintState.mMode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
|
||||
nsIntRegion drawRegionCopy = aPaintState.mRegionToDraw;
|
||||
RefPtr<DrawTarget> onBlack = GetUpdateSurface(BUFFER_BLACK, drawRegionCopy);
|
||||
RefPtr<DrawTarget> onWhite = GetUpdateSurface(BUFFER_WHITE, aPaintState.mRegionToDraw);
|
||||
if (onBlack && onWhite) {
|
||||
NS_ASSERTION(aPaintState.mRegionToDraw == drawRegionCopy,
|
||||
"BeginUpdate should always modify the draw region in the same way!");
|
||||
FillSurface(onBlack, aPaintState.mRegionToDraw, nsIntPoint(drawBounds.x, drawBounds.y), gfxRGBA(0.0, 0.0, 0.0, 1.0));
|
||||
FillSurface(onWhite, aPaintState.mRegionToDraw, nsIntPoint(drawBounds.x, drawBounds.y), gfxRGBA(1.0, 1.0, 1.0, 1.0));
|
||||
mLoanedDrawTarget = Factory::CreateDualDrawTarget(onBlack, onWhite);
|
||||
} else {
|
||||
mLoanedDrawTarget = nullptr;
|
||||
}
|
||||
} else {
|
||||
mLoanedDrawTarget = GetUpdateSurface(BUFFER_BLACK, aPaintState.mRegionToDraw);
|
||||
}
|
||||
if (!mLoanedDrawTarget) {
|
||||
NS_WARNING("unable to get context for update");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
result = mLoanedDrawTarget;
|
||||
mLoanedTransform = mLoanedDrawTarget->GetTransform();
|
||||
result->SetTransform(Matrix(mLoanedTransform).
|
||||
PreTranslate(-drawBounds.x, -drawBounds.y));
|
||||
|
||||
if (mContentType == gfxContentType::COLOR_ALPHA) {
|
||||
gfxUtils::ClipToRegion(result, aPaintState.mRegionToDraw);
|
||||
nsIntRect bounds = aPaintState.mRegionToDraw.GetBounds();
|
||||
result->ClearRect(Rect(bounds.x, bounds.y, bounds.width, bounds.height));
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void
|
||||
ContentClientIncremental::Updated(const nsIntRegion& aRegionToDraw,
|
||||
const nsIntRegion& aVisibleRegion,
|
||||
bool aDidSelfCopy)
|
||||
{
|
||||
if (IsSurfaceDescriptorValid(mUpdateDescriptor)) {
|
||||
mForwarder->UpdateTextureIncremental(this,
|
||||
TextureIdentifier::Front,
|
||||
mUpdateDescriptor,
|
||||
aRegionToDraw,
|
||||
mBufferRect,
|
||||
mBufferRotation);
|
||||
mUpdateDescriptor = SurfaceDescriptor();
|
||||
}
|
||||
if (IsSurfaceDescriptorValid(mUpdateDescriptorOnWhite)) {
|
||||
mForwarder->UpdateTextureIncremental(this,
|
||||
TextureIdentifier::OnWhiteFront,
|
||||
mUpdateDescriptorOnWhite,
|
||||
aRegionToDraw,
|
||||
mBufferRect,
|
||||
mBufferRotation);
|
||||
mUpdateDescriptorOnWhite = SurfaceDescriptor();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
TemporaryRef<DrawTarget>
|
||||
ContentClientIncremental::GetUpdateSurface(BufferType aType,
|
||||
const nsIntRegion& aUpdateRegion)
|
||||
{
|
||||
nsIntRect rgnSize = aUpdateRegion.GetBounds();
|
||||
if (!mBufferRect.Contains(rgnSize)) {
|
||||
NS_ERROR("update outside of image");
|
||||
return nullptr;
|
||||
}
|
||||
SurfaceDescriptor desc;
|
||||
if (!mForwarder->AllocSurfaceDescriptor(rgnSize.Size().ToIntSize(),
|
||||
mContentType,
|
||||
&desc)) {
|
||||
NS_WARNING("creating SurfaceDescriptor failed!");
|
||||
Clear();
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (aType == BUFFER_BLACK) {
|
||||
MOZ_ASSERT(!IsSurfaceDescriptorValid(mUpdateDescriptor));
|
||||
mUpdateDescriptor = desc;
|
||||
} else {
|
||||
MOZ_ASSERT(!IsSurfaceDescriptorValid(mUpdateDescriptorOnWhite));
|
||||
MOZ_ASSERT(aType == BUFFER_WHITE);
|
||||
mUpdateDescriptorOnWhite = desc;
|
||||
}
|
||||
|
||||
return GetDrawTargetForDescriptor(desc, gfx::BackendType::COREGRAPHICS);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -397,89 +397,6 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* A single buffered ContentClient that creates temporary buffers which are
|
||||
* used to update the host-side texture. The ownership of the buffers is
|
||||
* passed to the host side during the transaction, and we need to create
|
||||
* new ones each frame.
|
||||
*/
|
||||
class ContentClientIncremental : public ContentClientRemote
|
||||
, public BorrowDrawTarget
|
||||
{
|
||||
public:
|
||||
explicit ContentClientIncremental(CompositableForwarder* aFwd)
|
||||
: ContentClientRemote(aFwd)
|
||||
, mContentType(gfxContentType::COLOR_ALPHA)
|
||||
, mHasBuffer(false)
|
||||
, mHasBufferOnWhite(false)
|
||||
{
|
||||
mTextureInfo.mCompositableType = CompositableType::CONTENT_INC;
|
||||
}
|
||||
|
||||
typedef RotatedContentBuffer::PaintState PaintState;
|
||||
typedef RotatedContentBuffer::ContentType ContentType;
|
||||
|
||||
virtual TextureInfo GetTextureInfo() const MOZ_OVERRIDE
|
||||
{
|
||||
return mTextureInfo;
|
||||
}
|
||||
|
||||
virtual void Clear() MOZ_OVERRIDE
|
||||
{
|
||||
mBufferRect.SetEmpty();
|
||||
mHasBuffer = false;
|
||||
mHasBufferOnWhite = false;
|
||||
}
|
||||
|
||||
virtual PaintState BeginPaintBuffer(PaintedLayer* aLayer,
|
||||
uint32_t aFlags) MOZ_OVERRIDE;
|
||||
virtual gfx::DrawTarget* BorrowDrawTargetForPainting(PaintState& aPaintState,
|
||||
RotatedContentBuffer::DrawIterator* aIter = nullptr) MOZ_OVERRIDE;
|
||||
virtual void ReturnDrawTargetToBuffer(gfx::DrawTarget*& aReturned) MOZ_OVERRIDE
|
||||
{
|
||||
BorrowDrawTarget::ReturnDrawTarget(aReturned);
|
||||
}
|
||||
|
||||
virtual void Updated(const nsIntRegion& aRegionToDraw,
|
||||
const nsIntRegion& aVisibleRegion,
|
||||
bool aDidSelfCopy) MOZ_OVERRIDE;
|
||||
|
||||
virtual void EndPaint(nsTArray<ReadbackProcessor::Update>* aReadbackUpdates = nullptr) MOZ_OVERRIDE
|
||||
{
|
||||
if (IsSurfaceDescriptorValid(mUpdateDescriptor)) {
|
||||
mForwarder->DestroySharedSurface(&mUpdateDescriptor);
|
||||
}
|
||||
if (IsSurfaceDescriptorValid(mUpdateDescriptorOnWhite)) {
|
||||
mForwarder->DestroySharedSurface(&mUpdateDescriptorOnWhite);
|
||||
}
|
||||
ContentClientRemote::EndPaint(aReadbackUpdates);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
enum BufferType{
|
||||
BUFFER_BLACK,
|
||||
BUFFER_WHITE
|
||||
};
|
||||
|
||||
void NotifyBufferCreated(ContentType aType, TextureFlags aFlags);
|
||||
|
||||
TemporaryRef<gfx::DrawTarget> GetUpdateSurface(BufferType aType,
|
||||
const nsIntRegion& aUpdateRegion);
|
||||
|
||||
TextureInfo mTextureInfo;
|
||||
nsIntRect mBufferRect;
|
||||
nsIntPoint mBufferRotation;
|
||||
|
||||
SurfaceDescriptor mUpdateDescriptor;
|
||||
SurfaceDescriptor mUpdateDescriptorOnWhite;
|
||||
|
||||
ContentType mContentType;
|
||||
|
||||
bool mHasBuffer;
|
||||
bool mHasBufferOnWhite;
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -181,9 +181,6 @@ CompositableHost::Create(const TextureInfo& aTextureInfo)
|
|||
case CompositableType::IMAGE_BRIDGE:
|
||||
NS_ERROR("Cannot create an image bridge compositable this way");
|
||||
break;
|
||||
case CompositableType::CONTENT_INC:
|
||||
result = new ContentHostIncremental(aTextureInfo);
|
||||
break;
|
||||
case CompositableType::CONTENT_TILED:
|
||||
result = new TiledContentHost(aTextureInfo);
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -101,45 +101,6 @@ public:
|
|||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Update the content host using a surface that only contains the updated
|
||||
* region.
|
||||
*
|
||||
* Takes ownership of aSurface, and is responsible for freeing it.
|
||||
*
|
||||
* @param aTextureId Texture to update.
|
||||
* @param aSurface Surface containing the update area. Its contents are relative
|
||||
* to aUpdated.TopLeft()
|
||||
* @param aUpdated Area of the content host to update.
|
||||
* @param aBufferRect New area covered by the content host.
|
||||
* @param aBufferRotation New buffer rotation.
|
||||
*/
|
||||
virtual void UpdateIncremental(TextureIdentifier aTextureId,
|
||||
SurfaceDescriptor& aSurface,
|
||||
const nsIntRegion& aUpdated,
|
||||
const nsIntRect& aBufferRect,
|
||||
const nsIntPoint& aBufferRotation)
|
||||
{
|
||||
MOZ_ASSERT(false, "should be implemented or not used");
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensure that a suitable texture host exists in this compsitable.
|
||||
*
|
||||
* Only used with ContentHostIncremental.
|
||||
*
|
||||
* No SurfaceDescriptor or TextureIdentifier is provider as we
|
||||
* don't have a single surface for the texture contents, and we
|
||||
* need to allocate our own one to be updated later.
|
||||
*/
|
||||
virtual bool CreatedIncrementalTexture(ISurfaceAllocator* aAllocator,
|
||||
const TextureInfo& aTextureInfo,
|
||||
const nsIntRect& aBufferRect)
|
||||
{
|
||||
NS_ERROR("should be implemented or not used");
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the front buffer.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -388,429 +388,6 @@ ContentHostDoubleBuffered::UpdateThebes(const ThebesBufferData& aData,
|
|||
return true;
|
||||
}
|
||||
|
||||
ContentHostIncremental::ContentHostIncremental(const TextureInfo& aTextureInfo)
|
||||
: ContentHostBase(aTextureInfo)
|
||||
, mDeAllocator(nullptr)
|
||||
, mLocked(false)
|
||||
{
|
||||
}
|
||||
|
||||
ContentHostIncremental::~ContentHostIncremental()
|
||||
{
|
||||
}
|
||||
|
||||
bool
|
||||
ContentHostIncremental::CreatedIncrementalTexture(ISurfaceAllocator* aAllocator,
|
||||
const TextureInfo& aTextureInfo,
|
||||
const nsIntRect& aBufferRect)
|
||||
{
|
||||
mUpdateList.AppendElement(new TextureCreationRequest(aTextureInfo,
|
||||
aBufferRect));
|
||||
mDeAllocator = aAllocator;
|
||||
FlushUpdateQueue();
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
ContentHostIncremental::UpdateIncremental(TextureIdentifier aTextureId,
|
||||
SurfaceDescriptor& aSurface,
|
||||
const nsIntRegion& aUpdated,
|
||||
const nsIntRect& aBufferRect,
|
||||
const nsIntPoint& aBufferRotation)
|
||||
{
|
||||
mUpdateList.AppendElement(new TextureUpdateRequest(mDeAllocator,
|
||||
aTextureId,
|
||||
aSurface,
|
||||
aUpdated,
|
||||
aBufferRect,
|
||||
aBufferRotation));
|
||||
FlushUpdateQueue();
|
||||
}
|
||||
|
||||
void
|
||||
ContentHostIncremental::Composite(EffectChain& aEffectChain,
|
||||
float aOpacity,
|
||||
const gfx::Matrix4x4& aTransform,
|
||||
const Filter& aFilter,
|
||||
const Rect& aClipRect,
|
||||
const nsIntRegion* aVisibleRegion)
|
||||
{
|
||||
NS_ASSERTION(aVisibleRegion, "Requires a visible region");
|
||||
|
||||
AutoLockCompositableHost lock(this);
|
||||
if (lock.Failed()) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!mSource) {
|
||||
return;
|
||||
}
|
||||
|
||||
RefPtr<TexturedEffect> effect = CreateTexturedEffect(mSource.get(),
|
||||
mSourceOnWhite.get(),
|
||||
aFilter, true);
|
||||
if (!effect) {
|
||||
return;
|
||||
}
|
||||
|
||||
aEffectChain.mPrimaryEffect = effect;
|
||||
|
||||
nsIntRegion tmpRegion;
|
||||
const nsIntRegion* renderRegion;
|
||||
if (PaintWillResample()) {
|
||||
// If we're resampling, then the texture image will contain exactly the
|
||||
// entire visible region's bounds, and we should draw it all in one quad
|
||||
// to avoid unexpected aliasing.
|
||||
tmpRegion = aVisibleRegion->GetBounds();
|
||||
renderRegion = &tmpRegion;
|
||||
} else {
|
||||
renderRegion = aVisibleRegion;
|
||||
}
|
||||
|
||||
nsIntRegion region(*renderRegion);
|
||||
nsIntPoint origin = GetOriginOffset();
|
||||
// translate into TexImage space, buffer origin might not be at texture (0,0)
|
||||
region.MoveBy(-origin);
|
||||
|
||||
// Figure out the intersecting draw region
|
||||
gfx::IntSize texSize = mSource->GetSize();
|
||||
nsIntRect textureRect = nsIntRect(0, 0, texSize.width, texSize.height);
|
||||
textureRect.MoveBy(region.GetBounds().TopLeft());
|
||||
nsIntRegion subregion;
|
||||
subregion.And(region, textureRect);
|
||||
if (subregion.IsEmpty()) {
|
||||
// Region is empty, nothing to draw
|
||||
return;
|
||||
}
|
||||
|
||||
nsIntRegion screenRects;
|
||||
nsIntRegion regionRects;
|
||||
|
||||
// Collect texture/screen coordinates for drawing
|
||||
nsIntRegionRectIterator iter(subregion);
|
||||
while (const nsIntRect* iterRect = iter.Next()) {
|
||||
nsIntRect regionRect = *iterRect;
|
||||
nsIntRect screenRect = regionRect;
|
||||
screenRect.MoveBy(origin);
|
||||
|
||||
screenRects.Or(screenRects, screenRect);
|
||||
regionRects.Or(regionRects, regionRect);
|
||||
}
|
||||
|
||||
BigImageIterator* bigImgIter = mSource->AsBigImageIterator();
|
||||
BigImageIterator* iterOnWhite = nullptr;
|
||||
if (bigImgIter) {
|
||||
bigImgIter->BeginBigImageIteration();
|
||||
}
|
||||
|
||||
if (mSourceOnWhite) {
|
||||
iterOnWhite = mSourceOnWhite->AsBigImageIterator();
|
||||
MOZ_ASSERT(!bigImgIter || bigImgIter->GetTileCount() == iterOnWhite->GetTileCount(),
|
||||
"Tile count mismatch on component alpha texture");
|
||||
if (iterOnWhite) {
|
||||
iterOnWhite->BeginBigImageIteration();
|
||||
}
|
||||
}
|
||||
|
||||
bool usingTiles = (bigImgIter && bigImgIter->GetTileCount() > 1);
|
||||
do {
|
||||
if (iterOnWhite) {
|
||||
MOZ_ASSERT(iterOnWhite->GetTileRect() == bigImgIter->GetTileRect(),
|
||||
"component alpha textures should be the same size.");
|
||||
}
|
||||
|
||||
nsIntRect texRect = bigImgIter ? bigImgIter->GetTileRect()
|
||||
: nsIntRect(0, 0,
|
||||
texSize.width,
|
||||
texSize.height);
|
||||
|
||||
// Draw texture. If we're using tiles, we do repeating manually, as texture
|
||||
// repeat would cause each individual tile to repeat instead of the
|
||||
// compound texture as a whole. This involves drawing at most 4 sections,
|
||||
// 2 for each axis that has texture repeat.
|
||||
for (int y = 0; y < (usingTiles ? 2 : 1); y++) {
|
||||
for (int x = 0; x < (usingTiles ? 2 : 1); x++) {
|
||||
nsIntRect currentTileRect(texRect);
|
||||
currentTileRect.MoveBy(x * texSize.width, y * texSize.height);
|
||||
|
||||
nsIntRegionRectIterator screenIter(screenRects);
|
||||
nsIntRegionRectIterator regionIter(regionRects);
|
||||
|
||||
const nsIntRect* screenRect;
|
||||
const nsIntRect* regionRect;
|
||||
while ((screenRect = screenIter.Next()) &&
|
||||
(regionRect = regionIter.Next())) {
|
||||
nsIntRect tileScreenRect(*screenRect);
|
||||
nsIntRect tileRegionRect(*regionRect);
|
||||
|
||||
// When we're using tiles, find the intersection between the tile
|
||||
// rect and this region rect. Tiling is then handled by the
|
||||
// outer for-loops and modifying the tile rect.
|
||||
if (usingTiles) {
|
||||
tileScreenRect.MoveBy(-origin);
|
||||
tileScreenRect = tileScreenRect.Intersect(currentTileRect);
|
||||
tileScreenRect.MoveBy(origin);
|
||||
|
||||
if (tileScreenRect.IsEmpty())
|
||||
continue;
|
||||
|
||||
tileRegionRect = regionRect->Intersect(currentTileRect);
|
||||
tileRegionRect.MoveBy(-currentTileRect.TopLeft());
|
||||
}
|
||||
gfx::Rect rect(tileScreenRect.x, tileScreenRect.y,
|
||||
tileScreenRect.width, tileScreenRect.height);
|
||||
|
||||
effect->mTextureCoords = Rect(Float(tileRegionRect.x) / texRect.width,
|
||||
Float(tileRegionRect.y) / texRect.height,
|
||||
Float(tileRegionRect.width) / texRect.width,
|
||||
Float(tileRegionRect.height) / texRect.height);
|
||||
GetCompositor()->DrawQuad(rect, aClipRect, aEffectChain, aOpacity, aTransform);
|
||||
if (usingTiles) {
|
||||
DiagnosticFlags diagnostics = DiagnosticFlags::CONTENT | DiagnosticFlags::BIGIMAGE;
|
||||
if (iterOnWhite) {
|
||||
diagnostics |= DiagnosticFlags::COMPONENT_ALPHA;
|
||||
}
|
||||
GetCompositor()->DrawDiagnostics(diagnostics, rect, aClipRect,
|
||||
aTransform, mFlashCounter);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (iterOnWhite) {
|
||||
iterOnWhite->NextTile();
|
||||
}
|
||||
} while (usingTiles && bigImgIter->NextTile());
|
||||
|
||||
if (bigImgIter) {
|
||||
bigImgIter->EndBigImageIteration();
|
||||
}
|
||||
if (iterOnWhite) {
|
||||
iterOnWhite->EndBigImageIteration();
|
||||
}
|
||||
|
||||
DiagnosticFlags diagnostics = DiagnosticFlags::CONTENT;
|
||||
if (iterOnWhite) {
|
||||
diagnostics |= DiagnosticFlags::COMPONENT_ALPHA;
|
||||
}
|
||||
GetCompositor()->DrawDiagnostics(diagnostics, nsIntRegion(mBufferRect), aClipRect,
|
||||
aTransform, mFlashCounter);
|
||||
}
|
||||
|
||||
void
|
||||
ContentHostIncremental::FlushUpdateQueue()
|
||||
{
|
||||
// If we're not compositing for some reason (the window being minimized
|
||||
// is one example), then we never process these updates and it can consume
|
||||
// huge amounts of memory. Instead we forcibly process the updates (during the
|
||||
// transaction) if the list gets too long.
|
||||
static const uint32_t kMaxUpdateCount = 6;
|
||||
if (mUpdateList.Length() >= kMaxUpdateCount) {
|
||||
ProcessTextureUpdates();
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ContentHostIncremental::ProcessTextureUpdates()
|
||||
{
|
||||
for (uint32_t i = 0; i < mUpdateList.Length(); i++) {
|
||||
mUpdateList[i]->Execute(this);
|
||||
}
|
||||
mUpdateList.Clear();
|
||||
}
|
||||
|
||||
void
|
||||
ContentHostIncremental::TextureCreationRequest::Execute(ContentHostIncremental* aHost)
|
||||
{
|
||||
Compositor* compositor = aHost->GetCompositor();
|
||||
MOZ_ASSERT(compositor);
|
||||
|
||||
RefPtr<DataTextureSource> temp =
|
||||
compositor->CreateDataTextureSource(mTextureInfo.mTextureFlags);
|
||||
MOZ_ASSERT(temp->AsSourceOGL() &&
|
||||
temp->AsSourceOGL()->AsTextureImageTextureSource());
|
||||
RefPtr<TextureImageTextureSourceOGL> newSource =
|
||||
temp->AsSourceOGL()->AsTextureImageTextureSource();
|
||||
|
||||
RefPtr<TextureImageTextureSourceOGL> newSourceOnWhite;
|
||||
if (mTextureInfo.mTextureFlags & TextureFlags::COMPONENT_ALPHA) {
|
||||
temp =
|
||||
compositor->CreateDataTextureSource(mTextureInfo.mTextureFlags);
|
||||
MOZ_ASSERT(temp->AsSourceOGL() &&
|
||||
temp->AsSourceOGL()->AsTextureImageTextureSource());
|
||||
newSourceOnWhite = temp->AsSourceOGL()->AsTextureImageTextureSource();
|
||||
}
|
||||
|
||||
if (mTextureInfo.mDeprecatedTextureHostFlags & DeprecatedTextureHostFlags::COPY_PREVIOUS) {
|
||||
MOZ_ASSERT(aHost->mSource);
|
||||
MOZ_ASSERT(aHost->mSource->IsValid());
|
||||
nsIntRect bufferRect = aHost->mBufferRect;
|
||||
nsIntPoint bufferRotation = aHost->mBufferRotation;
|
||||
nsIntRect overlap;
|
||||
|
||||
// The buffer looks like:
|
||||
// ______
|
||||
// |1 |2 | Where the center point is offset by mBufferRotation from the top-left corner.
|
||||
// |___|__|
|
||||
// |3 |4 |
|
||||
// |___|__|
|
||||
//
|
||||
// This is drawn to the screen as:
|
||||
// ______
|
||||
// |4 |3 | Where the center point is { width - mBufferRotation.x, height - mBufferRotation.y } from
|
||||
// |___|__| from the top left corner - rotationPoint.
|
||||
// |2 |1 |
|
||||
// |___|__|
|
||||
//
|
||||
|
||||
// The basic idea below is to take all quadrant rectangles from the src and transform them into rectangles
|
||||
// in the destination. Unfortunately, it seems it is overly complex and could perhaps be simplified.
|
||||
|
||||
nsIntRect srcBufferSpaceBottomRight(bufferRotation.x, bufferRotation.y, bufferRect.width - bufferRotation.x, bufferRect.height - bufferRotation.y);
|
||||
nsIntRect srcBufferSpaceTopRight(bufferRotation.x, 0, bufferRect.width - bufferRotation.x, bufferRotation.y);
|
||||
nsIntRect srcBufferSpaceTopLeft(0, 0, bufferRotation.x, bufferRotation.y);
|
||||
nsIntRect srcBufferSpaceBottomLeft(0, bufferRotation.y, bufferRotation.x, bufferRect.height - bufferRotation.y);
|
||||
|
||||
overlap.IntersectRect(bufferRect, mBufferRect);
|
||||
|
||||
nsIntRect srcRect(overlap), dstRect(overlap);
|
||||
srcRect.MoveBy(- bufferRect.TopLeft() + bufferRotation);
|
||||
|
||||
nsIntRect srcRectDrawTopRight(srcRect);
|
||||
nsIntRect srcRectDrawTopLeft(srcRect);
|
||||
nsIntRect srcRectDrawBottomLeft(srcRect);
|
||||
// transform into the different quadrants
|
||||
srcRectDrawTopRight .MoveBy(-nsIntPoint(0, bufferRect.height));
|
||||
srcRectDrawTopLeft .MoveBy(-nsIntPoint(bufferRect.width, bufferRect.height));
|
||||
srcRectDrawBottomLeft.MoveBy(-nsIntPoint(bufferRect.width, 0));
|
||||
|
||||
// Intersect with the quadrant
|
||||
srcRect = srcRect .Intersect(srcBufferSpaceBottomRight);
|
||||
srcRectDrawTopRight = srcRectDrawTopRight .Intersect(srcBufferSpaceTopRight);
|
||||
srcRectDrawTopLeft = srcRectDrawTopLeft .Intersect(srcBufferSpaceTopLeft);
|
||||
srcRectDrawBottomLeft = srcRectDrawBottomLeft.Intersect(srcBufferSpaceBottomLeft);
|
||||
|
||||
dstRect = srcRect;
|
||||
nsIntRect dstRectDrawTopRight(srcRectDrawTopRight);
|
||||
nsIntRect dstRectDrawTopLeft(srcRectDrawTopLeft);
|
||||
nsIntRect dstRectDrawBottomLeft(srcRectDrawBottomLeft);
|
||||
|
||||
// transform back to src buffer space
|
||||
dstRect .MoveBy(-bufferRotation);
|
||||
dstRectDrawTopRight .MoveBy(-bufferRotation + nsIntPoint(0, bufferRect.height));
|
||||
dstRectDrawTopLeft .MoveBy(-bufferRotation + nsIntPoint(bufferRect.width, bufferRect.height));
|
||||
dstRectDrawBottomLeft.MoveBy(-bufferRotation + nsIntPoint(bufferRect.width, 0));
|
||||
|
||||
// transform back to draw coordinates
|
||||
dstRect .MoveBy(bufferRect.TopLeft());
|
||||
dstRectDrawTopRight .MoveBy(bufferRect.TopLeft());
|
||||
dstRectDrawTopLeft .MoveBy(bufferRect.TopLeft());
|
||||
dstRectDrawBottomLeft.MoveBy(bufferRect.TopLeft());
|
||||
|
||||
// transform to destBuffer space
|
||||
dstRect .MoveBy(-mBufferRect.TopLeft());
|
||||
dstRectDrawTopRight .MoveBy(-mBufferRect.TopLeft());
|
||||
dstRectDrawTopLeft .MoveBy(-mBufferRect.TopLeft());
|
||||
dstRectDrawBottomLeft.MoveBy(-mBufferRect.TopLeft());
|
||||
|
||||
newSource->EnsureBuffer(mBufferRect.Size(),
|
||||
ContentForFormat(aHost->mSource->GetFormat()));
|
||||
|
||||
aHost->mSource->CopyTo(srcRect, newSource, dstRect);
|
||||
if (bufferRotation != nsIntPoint(0, 0)) {
|
||||
// Draw the remaining quadrants. We call BlitTextureImage 3 extra
|
||||
// times instead of doing a single draw call because supporting that
|
||||
// with a tiled source is quite tricky.
|
||||
|
||||
if (!srcRectDrawTopRight.IsEmpty())
|
||||
aHost->mSource->CopyTo(srcRectDrawTopRight,
|
||||
newSource, dstRectDrawTopRight);
|
||||
if (!srcRectDrawTopLeft.IsEmpty())
|
||||
aHost->mSource->CopyTo(srcRectDrawTopLeft,
|
||||
newSource, dstRectDrawTopLeft);
|
||||
if (!srcRectDrawBottomLeft.IsEmpty())
|
||||
aHost->mSource->CopyTo(srcRectDrawBottomLeft,
|
||||
newSource, dstRectDrawBottomLeft);
|
||||
}
|
||||
|
||||
if (newSourceOnWhite) {
|
||||
newSourceOnWhite->EnsureBuffer(mBufferRect.Size(),
|
||||
ContentForFormat(aHost->mSourceOnWhite->GetFormat()));
|
||||
aHost->mSourceOnWhite->CopyTo(srcRect, newSourceOnWhite, dstRect);
|
||||
if (bufferRotation != nsIntPoint(0, 0)) {
|
||||
// draw the remaining quadrants
|
||||
if (!srcRectDrawTopRight.IsEmpty())
|
||||
aHost->mSourceOnWhite->CopyTo(srcRectDrawTopRight,
|
||||
newSourceOnWhite, dstRectDrawTopRight);
|
||||
if (!srcRectDrawTopLeft.IsEmpty())
|
||||
aHost->mSourceOnWhite->CopyTo(srcRectDrawTopLeft,
|
||||
newSourceOnWhite, dstRectDrawTopLeft);
|
||||
if (!srcRectDrawBottomLeft.IsEmpty())
|
||||
aHost->mSourceOnWhite->CopyTo(srcRectDrawBottomLeft,
|
||||
newSourceOnWhite, dstRectDrawBottomLeft);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
aHost->mSource = newSource;
|
||||
aHost->mSourceOnWhite = newSourceOnWhite;
|
||||
|
||||
aHost->mBufferRect = mBufferRect;
|
||||
aHost->mBufferRotation = nsIntPoint();
|
||||
}
|
||||
|
||||
nsIntRect
|
||||
ContentHostIncremental::TextureUpdateRequest::GetQuadrantRectangle(XSide aXSide,
|
||||
YSide aYSide) const
|
||||
{
|
||||
// quadrantTranslation is the amount we translate the top-left
|
||||
// of the quadrant by to get coordinates relative to the layer
|
||||
nsIntPoint quadrantTranslation = -mBufferRotation;
|
||||
quadrantTranslation.x += aXSide == LEFT ? mBufferRect.width : 0;
|
||||
quadrantTranslation.y += aYSide == TOP ? mBufferRect.height : 0;
|
||||
return mBufferRect + quadrantTranslation;
|
||||
}
|
||||
|
||||
void
|
||||
ContentHostIncremental::TextureUpdateRequest::Execute(ContentHostIncremental* aHost)
|
||||
{
|
||||
nsIntRect drawBounds = mUpdated.GetBounds();
|
||||
|
||||
aHost->mBufferRect = mBufferRect;
|
||||
aHost->mBufferRotation = mBufferRotation;
|
||||
|
||||
// Figure out which quadrant to draw in
|
||||
int32_t xBoundary = mBufferRect.XMost() - mBufferRotation.x;
|
||||
int32_t yBoundary = mBufferRect.YMost() - mBufferRotation.y;
|
||||
XSide sideX = drawBounds.XMost() <= xBoundary ? RIGHT : LEFT;
|
||||
YSide sideY = drawBounds.YMost() <= yBoundary ? BOTTOM : TOP;
|
||||
nsIntRect quadrantRect = GetQuadrantRectangle(sideX, sideY);
|
||||
NS_ASSERTION(quadrantRect.Contains(drawBounds), "Messed up quadrants");
|
||||
|
||||
mUpdated.MoveBy(-nsIntPoint(quadrantRect.x, quadrantRect.y));
|
||||
|
||||
IntPoint offset = ToIntPoint(-mUpdated.GetBounds().TopLeft());
|
||||
|
||||
RefPtr<DataSourceSurface> surf = GetSurfaceForDescriptor(mDescriptor);
|
||||
|
||||
if (mTextureId == TextureIdentifier::Front) {
|
||||
aHost->mSource->Update(surf, &mUpdated, &offset);
|
||||
} else {
|
||||
aHost->mSourceOnWhite->Update(surf, &mUpdated, &offset);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ContentHostIncremental::PrintInfo(std::stringstream& aStream, const char* aPrefix)
|
||||
{
|
||||
aStream << aPrefix;
|
||||
aStream << nsPrintfCString("ContentHostIncremental (0x%p)", this).get();
|
||||
|
||||
if (PaintWillResample()) {
|
||||
aStream << " [paint-will-resample]";
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ContentHostTexture::PrintInfo(std::stringstream& aStream, const char* aPrefix)
|
||||
{
|
||||
|
|
@ -869,15 +446,6 @@ ContentHostTexture::GenEffect(const gfx::Filter& aFilter)
|
|||
aFilter, true);
|
||||
}
|
||||
|
||||
TemporaryRef<TexturedEffect>
|
||||
ContentHostIncremental::GenEffect(const gfx::Filter& aFilter)
|
||||
{
|
||||
if (!mSource) {
|
||||
return nullptr;
|
||||
}
|
||||
return CreateTexturedEffect(mSource, mSourceOnWhite, aFilter, true);
|
||||
}
|
||||
|
||||
TemporaryRef<gfx::DataSourceSurface>
|
||||
ContentHostTexture::GetAsSurface()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -223,160 +223,6 @@ public:
|
|||
nsIntRegion* aUpdatedRegionBack);
|
||||
};
|
||||
|
||||
/**
|
||||
* Maintains a host-side only texture, and gets provided with
|
||||
* surfaces that only cover the changed pixels during an update.
|
||||
*
|
||||
* Takes ownership of the passed in update surfaces, and must
|
||||
* free them once texture upload is complete.
|
||||
*
|
||||
* Delays texture uploads until the next composite to
|
||||
* avoid blocking the main thread.
|
||||
*/
|
||||
class ContentHostIncremental : public ContentHostBase
|
||||
{
|
||||
public:
|
||||
explicit ContentHostIncremental(const TextureInfo& aTextureInfo);
|
||||
~ContentHostIncremental();
|
||||
|
||||
virtual CompositableType GetType() MOZ_OVERRIDE { return CompositableType::CONTENT_INC; }
|
||||
|
||||
virtual LayerRenderState GetRenderState() MOZ_OVERRIDE { return LayerRenderState(); }
|
||||
|
||||
virtual bool CreatedIncrementalTexture(ISurfaceAllocator* aAllocator,
|
||||
const TextureInfo& aTextureInfo,
|
||||
const nsIntRect& aBufferRect) MOZ_OVERRIDE;
|
||||
|
||||
virtual void UpdateIncremental(TextureIdentifier aTextureId,
|
||||
SurfaceDescriptor& aSurface,
|
||||
const nsIntRegion& aUpdated,
|
||||
const nsIntRect& aBufferRect,
|
||||
const nsIntPoint& aBufferRotation) MOZ_OVERRIDE;
|
||||
|
||||
virtual bool UpdateThebes(const ThebesBufferData& aData,
|
||||
const nsIntRegion& aUpdated,
|
||||
const nsIntRegion& aOldValidRegionBack,
|
||||
nsIntRegion* aUpdatedRegionBack) MOZ_OVERRIDE
|
||||
{
|
||||
NS_ERROR("Shouldn't call this");
|
||||
return false;
|
||||
}
|
||||
|
||||
virtual void Composite(EffectChain& aEffectChain,
|
||||
float aOpacity,
|
||||
const gfx::Matrix4x4& aTransform,
|
||||
const gfx::Filter& aFilter,
|
||||
const gfx::Rect& aClipRect,
|
||||
const nsIntRegion* aVisibleRegion = nullptr) MOZ_OVERRIDE;
|
||||
|
||||
virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) MOZ_OVERRIDE;
|
||||
|
||||
virtual bool Lock() MOZ_OVERRIDE {
|
||||
MOZ_ASSERT(!mLocked);
|
||||
ProcessTextureUpdates();
|
||||
mLocked = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
virtual void Unlock() MOZ_OVERRIDE {
|
||||
MOZ_ASSERT(mLocked);
|
||||
mLocked = false;
|
||||
}
|
||||
|
||||
virtual TemporaryRef<TexturedEffect>
|
||||
GenEffect(const gfx::Filter& aFilter) MOZ_OVERRIDE;
|
||||
|
||||
private:
|
||||
|
||||
void FlushUpdateQueue();
|
||||
void ProcessTextureUpdates();
|
||||
|
||||
class Request
|
||||
{
|
||||
public:
|
||||
Request()
|
||||
{
|
||||
MOZ_COUNT_CTOR(ContentHostIncremental::Request);
|
||||
}
|
||||
|
||||
virtual ~Request()
|
||||
{
|
||||
MOZ_COUNT_DTOR(ContentHostIncremental::Request);
|
||||
}
|
||||
|
||||
virtual void Execute(ContentHostIncremental *aHost) = 0;
|
||||
};
|
||||
|
||||
class TextureCreationRequest : public Request
|
||||
{
|
||||
public:
|
||||
TextureCreationRequest(const TextureInfo& aTextureInfo,
|
||||
const nsIntRect& aBufferRect)
|
||||
: mTextureInfo(aTextureInfo)
|
||||
, mBufferRect(aBufferRect)
|
||||
{}
|
||||
|
||||
virtual void Execute(ContentHostIncremental *aHost);
|
||||
|
||||
private:
|
||||
TextureInfo mTextureInfo;
|
||||
nsIntRect mBufferRect;
|
||||
};
|
||||
|
||||
class TextureUpdateRequest : public Request
|
||||
{
|
||||
public:
|
||||
TextureUpdateRequest(ISurfaceAllocator* aDeAllocator,
|
||||
TextureIdentifier aTextureId,
|
||||
SurfaceDescriptor& aDescriptor,
|
||||
const nsIntRegion& aUpdated,
|
||||
const nsIntRect& aBufferRect,
|
||||
const nsIntPoint& aBufferRotation)
|
||||
: mDeAllocator(aDeAllocator)
|
||||
, mTextureId(aTextureId)
|
||||
, mDescriptor(aDescriptor)
|
||||
, mUpdated(aUpdated)
|
||||
, mBufferRect(aBufferRect)
|
||||
, mBufferRotation(aBufferRotation)
|
||||
{}
|
||||
|
||||
~TextureUpdateRequest()
|
||||
{
|
||||
//TODO: Recycle these?
|
||||
mDeAllocator->DestroySharedSurface(&mDescriptor);
|
||||
}
|
||||
|
||||
virtual void Execute(ContentHostIncremental *aHost);
|
||||
|
||||
private:
|
||||
enum XSide {
|
||||
LEFT, RIGHT
|
||||
};
|
||||
enum YSide {
|
||||
TOP, BOTTOM
|
||||
};
|
||||
|
||||
nsIntRect GetQuadrantRectangle(XSide aXSide, YSide aYSide) const;
|
||||
|
||||
RefPtr<ISurfaceAllocator> mDeAllocator;
|
||||
TextureIdentifier mTextureId;
|
||||
SurfaceDescriptor mDescriptor;
|
||||
nsIntRegion mUpdated;
|
||||
nsIntRect mBufferRect;
|
||||
nsIntPoint mBufferRotation;
|
||||
};
|
||||
|
||||
nsTArray<UniquePtr<Request> > mUpdateList;
|
||||
|
||||
// Specific to OGL to avoid exposing methods on TextureSource that only
|
||||
// have one implementation.
|
||||
RefPtr<TextureImageTextureSourceOGL> mSource;
|
||||
RefPtr<TextureImageTextureSourceOGL> mSourceOnWhite;
|
||||
|
||||
RefPtr<ISurfaceAllocator> mDeAllocator;
|
||||
bool mLocked;
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -53,7 +53,6 @@ bool
|
|||
PaintedLayerComposite::SetCompositableHost(CompositableHost* aHost)
|
||||
{
|
||||
switch (aHost->GetType()) {
|
||||
case CompositableType::CONTENT_INC:
|
||||
case CompositableType::CONTENT_TILED:
|
||||
case CompositableType::CONTENT_SINGLE:
|
||||
case CompositableType::CONTENT_DOUBLE:
|
||||
|
|
|
|||
|
|
@ -55,14 +55,6 @@ public:
|
|||
*/
|
||||
virtual void Connect(CompositableClient* aCompositable) = 0;
|
||||
|
||||
/**
|
||||
* Notify the CompositableHost that it should create host-side-only
|
||||
* texture(s), that we will update incrementally using UpdateTextureIncremental.
|
||||
*/
|
||||
virtual void CreatedIncrementalBuffer(CompositableClient* aCompositable,
|
||||
const TextureInfo& aTextureInfo,
|
||||
const nsIntRect& aBufferRect) = 0;
|
||||
|
||||
/**
|
||||
* Tell the CompositableHost on the compositor side what TiledLayerBuffer to
|
||||
* use for the next composition.
|
||||
|
|
@ -83,23 +75,6 @@ public:
|
|||
const ThebesBufferData& aThebesBufferData,
|
||||
const nsIntRegion& aUpdatedRegion) = 0;
|
||||
|
||||
/**
|
||||
* Notify the compositor to update aTextureId using aDescriptor, and take
|
||||
* ownership of aDescriptor.
|
||||
*
|
||||
* aDescriptor only contains the pixels for aUpdatedRegion, and is relative
|
||||
* to aUpdatedRegion.TopLeft().
|
||||
*
|
||||
* aBufferRect/aBufferRotation define the new valid region contained
|
||||
* within the texture after the update has been applied.
|
||||
*/
|
||||
virtual void UpdateTextureIncremental(CompositableClient* aCompositable,
|
||||
TextureIdentifier aTextureId,
|
||||
SurfaceDescriptor& aDescriptor,
|
||||
const nsIntRegion& aUpdatedRegion,
|
||||
const nsIntRect& aBufferRect,
|
||||
const nsIntPoint& aBufferRotation) = 0;
|
||||
|
||||
/**
|
||||
* Communicate the picture rect of a YUV image in aLayer to the compositor
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -73,20 +73,6 @@ CompositableParentManager::ReceiveCompositableUpdate(const CompositableOperation
|
|||
EditReplyVector& replyv)
|
||||
{
|
||||
switch (aEdit.type()) {
|
||||
case CompositableOperation::TOpCreatedIncrementalTexture: {
|
||||
MOZ_LAYERS_LOG(("[ParentSide] Created texture"));
|
||||
const OpCreatedIncrementalTexture& op = aEdit.get_OpCreatedIncrementalTexture();
|
||||
CompositableHost* compositable = AsCompositable(op);
|
||||
|
||||
bool success =
|
||||
compositable->CreatedIncrementalTexture(this,
|
||||
op.textureInfo(),
|
||||
op.bufferRect());
|
||||
if (!success) {
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case CompositableOperation::TOpPaintTextureRegion: {
|
||||
MOZ_LAYERS_LOG(("[ParentSide] Paint PaintedLayer"));
|
||||
|
||||
|
|
@ -116,22 +102,6 @@ CompositableParentManager::ReceiveCompositableUpdate(const CompositableOperation
|
|||
RenderTraceInvalidateEnd(thebes, "FF00FF");
|
||||
break;
|
||||
}
|
||||
case CompositableOperation::TOpPaintTextureIncremental: {
|
||||
MOZ_LAYERS_LOG(("[ParentSide] Paint PaintedLayer"));
|
||||
|
||||
const OpPaintTextureIncremental& op = aEdit.get_OpPaintTextureIncremental();
|
||||
|
||||
CompositableHost* compositable = AsCompositable(op);
|
||||
|
||||
SurfaceDescriptor desc = op.image();
|
||||
|
||||
compositable->UpdateIncremental(op.textureId(),
|
||||
desc,
|
||||
op.updatedRegion(),
|
||||
op.bufferRect(),
|
||||
op.bufferRotation());
|
||||
break;
|
||||
}
|
||||
case CompositableOperation::TOpUpdatePictureRect: {
|
||||
const OpUpdatePictureRect& op = aEdit.get_OpUpdatePictureRect();
|
||||
CompositableHost* compositable = AsCompositable(op);
|
||||
|
|
|
|||
|
|
@ -541,17 +541,6 @@ ImageBridgeChild::EndTransaction()
|
|||
for (nsTArray<EditReply>::size_type i = 0; i < replies.Length(); ++i) {
|
||||
const EditReply& reply = replies[i];
|
||||
switch (reply.type()) {
|
||||
case EditReply::TOpTextureSwap: {
|
||||
const OpTextureSwap& ots = reply.get_OpTextureSwap();
|
||||
|
||||
CompositableClient* compositable =
|
||||
CompositableClient::FromIPDLActor(ots.compositableChild());
|
||||
|
||||
MOZ_ASSERT(compositable);
|
||||
|
||||
compositable->SetDescriptorFromReply(ots.textureId(), ots.image());
|
||||
break;
|
||||
}
|
||||
case EditReply::TReturnReleaseFence: {
|
||||
const ReturnReleaseFence& rep = reply.get_ReturnReleaseFence();
|
||||
FenceHandle fence = rep.fence();
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
#include "mozilla/ipc/SharedMemory.h" // for SharedMemory, etc
|
||||
#include "mozilla/layers/AsyncTransactionTracker.h" // for AsyncTransactionTrackerHolder
|
||||
#include "mozilla/layers/CompositableForwarder.h"
|
||||
#include "mozilla/layers/CompositorTypes.h" // for TextureIdentifier, etc
|
||||
#include "mozilla/layers/CompositorTypes.h"
|
||||
#include "mozilla/layers/PImageBridgeChild.h"
|
||||
#include "nsDebug.h" // for NS_RUNTIMEABORT
|
||||
#include "nsRegion.h" // for nsIntRegion
|
||||
|
|
@ -248,16 +248,6 @@ public:
|
|||
NS_RUNTIMEABORT("should not be called");
|
||||
}
|
||||
|
||||
virtual void UpdateTextureIncremental(CompositableClient* aCompositable,
|
||||
TextureIdentifier aTextureId,
|
||||
SurfaceDescriptor& aDescriptor,
|
||||
const nsIntRegion& aUpdatedRegion,
|
||||
const nsIntRect& aBufferRect,
|
||||
const nsIntPoint& aBufferRotation) MOZ_OVERRIDE
|
||||
{
|
||||
NS_RUNTIMEABORT("should not be called");
|
||||
}
|
||||
|
||||
/**
|
||||
* Communicate the picture rect of a YUV image in aLayer to the compositor
|
||||
*/
|
||||
|
|
@ -265,12 +255,6 @@ public:
|
|||
const nsIntRect& aRect) MOZ_OVERRIDE;
|
||||
|
||||
|
||||
virtual void CreatedIncrementalBuffer(CompositableClient* aCompositable,
|
||||
const TextureInfo& aTextureInfo,
|
||||
const nsIntRect& aBufferRect) MOZ_OVERRIDE
|
||||
{
|
||||
NS_RUNTIMEABORT("should not be called");
|
||||
}
|
||||
virtual void UpdateTextureRegion(CompositableClient* aCompositable,
|
||||
const ThebesBufferData& aThebesBufferData,
|
||||
const nsIntRegion& aUpdatedRegion) MOZ_OVERRIDE {
|
||||
|
|
|
|||
|
|
@ -41,7 +41,6 @@ using struct mozilla::layers::FrameMetrics from "FrameMetrics.h";
|
|||
using mozilla::layers::FrameMetrics::ViewID from "FrameMetrics.h";
|
||||
using struct mozilla::layers::FenceHandle from "mozilla/layers/FenceUtils.h";
|
||||
using struct mozilla::layers::FenceHandleFromChild from "mozilla/layers/FenceUtils.h";
|
||||
using mozilla::layers::TextureIdentifier from "mozilla/layers/CompositorTypes.h";
|
||||
using std::string from "string";
|
||||
|
||||
namespace mozilla {
|
||||
|
|
@ -339,27 +338,12 @@ struct OpUseOverlaySource {
|
|||
OverlaySource overlay;
|
||||
};
|
||||
|
||||
struct OpCreatedIncrementalTexture {
|
||||
PCompositable compositable;
|
||||
TextureInfo textureInfo;
|
||||
nsIntRect bufferRect;
|
||||
};
|
||||
|
||||
struct OpPaintTextureRegion {
|
||||
PCompositable compositable;
|
||||
ThebesBufferData bufferData;
|
||||
nsIntRegion updatedRegion;
|
||||
};
|
||||
|
||||
struct OpPaintTextureIncremental {
|
||||
PCompositable compositable;
|
||||
TextureIdentifier textureId;
|
||||
SurfaceDescriptor image;
|
||||
nsIntRegion updatedRegion;
|
||||
nsIntRect bufferRect;
|
||||
nsIntPoint bufferRotation;
|
||||
};
|
||||
|
||||
struct OpUpdatePictureRect {
|
||||
PCompositable compositable;
|
||||
nsIntRect picture;
|
||||
|
|
@ -438,10 +422,7 @@ struct OpReplyDeliverFence {
|
|||
union CompositableOperation {
|
||||
OpUpdatePictureRect;
|
||||
|
||||
OpCreatedIncrementalTexture;
|
||||
|
||||
OpPaintTextureRegion;
|
||||
OpPaintTextureIncremental;
|
||||
|
||||
OpUseTiledLayerBuffer;
|
||||
|
||||
|
|
@ -487,12 +468,6 @@ struct OpContentBufferSwap {
|
|||
nsIntRegion frontUpdatedRegion;
|
||||
};
|
||||
|
||||
struct OpTextureSwap {
|
||||
PCompositable compositable;
|
||||
TextureIdentifier textureId;
|
||||
SurfaceDescriptor image;
|
||||
};
|
||||
|
||||
struct ReturnReleaseFence {
|
||||
PCompositable compositable;
|
||||
PTexture texture;
|
||||
|
|
@ -503,7 +478,6 @@ struct ReturnReleaseFence {
|
|||
// only to be used for buffer swapping.
|
||||
union EditReply {
|
||||
OpContentBufferSwap;
|
||||
OpTextureSwap;
|
||||
|
||||
ReturnReleaseFence;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -352,26 +352,6 @@ ShadowLayerForwarder::UpdateTextureRegion(CompositableClient* aCompositable,
|
|||
aUpdatedRegion));
|
||||
}
|
||||
|
||||
void
|
||||
ShadowLayerForwarder::UpdateTextureIncremental(CompositableClient* aCompositable,
|
||||
TextureIdentifier aTextureId,
|
||||
SurfaceDescriptor& aDescriptor,
|
||||
const nsIntRegion& aUpdatedRegion,
|
||||
const nsIntRect& aBufferRect,
|
||||
const nsIntPoint& aBufferRotation)
|
||||
{
|
||||
CheckSurfaceDescriptor(&aDescriptor);
|
||||
MOZ_ASSERT(aCompositable);
|
||||
MOZ_ASSERT(aCompositable->GetIPDLActor());
|
||||
mTxn->AddNoSwapPaint(OpPaintTextureIncremental(nullptr, aCompositable->GetIPDLActor(),
|
||||
aTextureId,
|
||||
aDescriptor,
|
||||
aUpdatedRegion,
|
||||
aBufferRect,
|
||||
aBufferRotation));
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
ShadowLayerForwarder::UpdatePictureRect(CompositableClient* aCompositable,
|
||||
const nsIntRect& aRect)
|
||||
|
|
@ -815,16 +795,6 @@ ShadowLayerForwarder::Connect(CompositableClient* aCompositable)
|
|||
aCompositable->InitIPDLActor(actor);
|
||||
}
|
||||
|
||||
void
|
||||
ShadowLayerForwarder::CreatedIncrementalBuffer(CompositableClient* aCompositable,
|
||||
const TextureInfo& aTextureInfo,
|
||||
const nsIntRect& aBufferRect)
|
||||
{
|
||||
MOZ_ASSERT(aCompositable);
|
||||
mTxn->AddNoSwapPaint(OpCreatedIncrementalTexture(nullptr, aCompositable->GetIPDLActor(),
|
||||
aTextureInfo, aBufferRect));
|
||||
}
|
||||
|
||||
void ShadowLayerForwarder::Attach(CompositableClient* aCompositable,
|
||||
ShadowableLayer* aLayer)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -133,7 +133,6 @@ class Transaction;
|
|||
|
||||
class ShadowLayerForwarder : public CompositableForwarder
|
||||
{
|
||||
friend class ContentClientIncremental;
|
||||
friend class ClientLayerManager;
|
||||
|
||||
public:
|
||||
|
|
@ -148,10 +147,6 @@ public:
|
|||
virtual PTextureChild* CreateTexture(const SurfaceDescriptor& aSharedData,
|
||||
TextureFlags aFlags) MOZ_OVERRIDE;
|
||||
|
||||
virtual void CreatedIncrementalBuffer(CompositableClient* aCompositable,
|
||||
const TextureInfo& aTextureInfo,
|
||||
const nsIntRect& aBufferRect) MOZ_OVERRIDE;
|
||||
|
||||
/**
|
||||
* Adds an edit in the layers transaction in order to attach
|
||||
* the corresponding compositable and layer on the compositor side.
|
||||
|
|
@ -259,13 +254,6 @@ public:
|
|||
const ThebesBufferData& aThebesBufferData,
|
||||
const nsIntRegion& aUpdatedRegion) MOZ_OVERRIDE;
|
||||
|
||||
virtual void UpdateTextureIncremental(CompositableClient* aCompositable,
|
||||
TextureIdentifier aTextureId,
|
||||
SurfaceDescriptor& aDescriptor,
|
||||
const nsIntRegion& aUpdatedRegion,
|
||||
const nsIntRect& aBufferRect,
|
||||
const nsIntPoint& aBufferRotation) MOZ_OVERRIDE;
|
||||
|
||||
/**
|
||||
* Communicate the picture rect of an image to the compositor
|
||||
*/
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче