diff --git a/gfx/layers/basic/BasicImplData.h b/gfx/layers/basic/BasicImplData.h new file mode 100644 index 000000000000..2b6b0e881ae1 --- /dev/null +++ b/gfx/layers/basic/BasicImplData.h @@ -0,0 +1,118 @@ +/* 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/. */ + +#ifndef GFX_BASICIMPLDATA_H +#define GFX_BASICIMPLDATA_H + +namespace mozilla { +namespace layers { + +/** + * This is the ImplData for all Basic layers. It also exposes methods + * private to the Basic implementation that are common to all Basic layer types. + * In particular, there is an internal Paint() method that we can use + * to paint the contents of non-Thebes layers. + * + * The class hierarchy for Basic layers is like this: + * BasicImplData + * Layer | | | + * | | | | + * +-> ContainerLayer | | | + * | | | | | + * | +-> BasicContainerLayer <--+ | | + * | | | + * +-> ThebesLayer | | + * | | | | + * | +-> BasicThebesLayer <---------+ | + * | | + * +-> ImageLayer | + * | | + * +-> BasicImageLayer <--------------+ + */ +class BasicImplData { +public: + BasicImplData() : mHidden(false), + mClipToVisibleRegion(false), + mDrawAtomically(false), + mOperator(gfxContext::OPERATOR_OVER) + { + MOZ_COUNT_CTOR(BasicImplData); + } + virtual ~BasicImplData() + { + MOZ_COUNT_DTOR(BasicImplData); + } + + /** + * Layers that paint themselves, such as ImageLayers, should paint + * in response to this method call. aContext will already have been + * set up to account for all the properties of the layer (transform, + * opacity, etc). + */ + virtual void Paint(gfxContext* aContext) {} + + /** + * Like Paint() but called for ThebesLayers with the additional parameters + * they need. + * If mClipToVisibleRegion is set, then the layer must clip to its + * effective visible region (snapped or unsnapped, it doesn't matter). + */ + virtual void PaintThebes(gfxContext* aContext, + LayerManager::DrawThebesLayerCallback aCallback, + void* aCallbackData, + ReadbackProcessor* aReadback) {} + + virtual ShadowableLayer* AsShadowableLayer() { return nsnull; } + + /** + * Implementations return true here if they *must* retain their + * layer contents. This is true of shadowable layers with shadows, + * because there's no target on which to composite directly in the + * layer-publishing child process. + */ + virtual bool MustRetainContent() { return false; } + + /** + * Layers will get this call when their layer manager is destroyed, this + * indicates they should clear resources they don't really need after their + * LayerManager ceases to exist. + */ + virtual void ClearCachedResources() {} + + /** + * This variable is set by MarkLayersHidden() before painting. It indicates + * that the layer should not be composited during this transaction. + */ + void SetHidden(bool aCovered) { mHidden = aCovered; } + bool IsHidden() const { return false; } + /** + * This variable is set by MarkLayersHidden() before painting. This is + * the operator to be used when compositing the layer in this transaction. It must + * be OVER or SOURCE. + */ + void SetOperator(gfxContext::GraphicsOperator aOperator) + { + NS_ASSERTION(aOperator == gfxContext::OPERATOR_OVER || + aOperator == gfxContext::OPERATOR_SOURCE, + "Bad composition operator"); + mOperator = aOperator; + } + gfxContext::GraphicsOperator GetOperator() const { return mOperator; } + + bool GetClipToVisibleRegion() { return mClipToVisibleRegion; } + void SetClipToVisibleRegion(bool aClip) { mClipToVisibleRegion = aClip; } + + void SetDrawAtomically(bool aDrawAtomically) { mDrawAtomically = aDrawAtomically; } + +protected: + bool mHidden; + bool mClipToVisibleRegion; + bool mDrawAtomically; + gfxContext::GraphicsOperator mOperator; +}; + +} // layers +} // mozilla + +#endif diff --git a/gfx/layers/basic/BasicLayers.cpp b/gfx/layers/basic/BasicLayers.cpp index b4eea8fd10cc..4444acf97d52 100644 --- a/gfx/layers/basic/BasicLayers.cpp +++ b/gfx/layers/basic/BasicLayers.cpp @@ -48,6 +48,7 @@ #include "ipc/ShadowLayerChild.h" #include "BasicLayers.h" +#include "BasicImplData.h" #include "ImageLayers.h" #include "RenderTrace.h" @@ -78,110 +79,6 @@ namespace layers { class BasicContainerLayer; class ShadowableLayer; -/** - * This is the ImplData for all Basic layers. It also exposes methods - * private to the Basic implementation that are common to all Basic layer types. - * In particular, there is an internal Paint() method that we can use - * to paint the contents of non-Thebes layers. - * - * The class hierarchy for Basic layers is like this: - * BasicImplData - * Layer | | | - * | | | | - * +-> ContainerLayer | | | - * | | | | | - * | +-> BasicContainerLayer <--+ | | - * | | | - * +-> ThebesLayer | | - * | | | | - * | +-> BasicThebesLayer <---------+ | - * | | - * +-> ImageLayer | - * | | - * +-> BasicImageLayer <--------------+ - */ -class BasicImplData { -public: - BasicImplData() : mHidden(false), - mClipToVisibleRegion(false), - mDrawAtomically(false), - mOperator(gfxContext::OPERATOR_OVER) - { - MOZ_COUNT_CTOR(BasicImplData); - } - virtual ~BasicImplData() - { - MOZ_COUNT_DTOR(BasicImplData); - } - - /** - * Layers that paint themselves, such as ImageLayers, should paint - * in response to this method call. aContext will already have been - * set up to account for all the properties of the layer (transform, - * opacity, etc). - */ - virtual void Paint(gfxContext* aContext) {} - - /** - * Like Paint() but called for ThebesLayers with the additional parameters - * they need. - * If mClipToVisibleRegion is set, then the layer must clip to its - * effective visible region (snapped or unsnapped, it doesn't matter). - */ - virtual void PaintThebes(gfxContext* aContext, - LayerManager::DrawThebesLayerCallback aCallback, - void* aCallbackData, - ReadbackProcessor* aReadback) {} - - virtual ShadowableLayer* AsShadowableLayer() { return nsnull; } - - /** - * Implementations return true here if they *must* retain their - * layer contents. This is true of shadowable layers with shadows, - * because there's no target on which to composite directly in the - * layer-publishing child process. - */ - virtual bool MustRetainContent() { return false; } - - /** - * Layers will get this call when their layer manager is destroyed, this - * indicates they should clear resources they don't really need after their - * LayerManager ceases to exist. - */ - virtual void ClearCachedResources() {} - - /** - * This variable is set by MarkLayersHidden() before painting. It indicates - * that the layer should not be composited during this transaction. - */ - void SetHidden(bool aCovered) { mHidden = aCovered; } - bool IsHidden() const { return false; } - /** - * This variable is set by MarkLayersHidden() before painting. This is - * the operator to be used when compositing the layer in this transaction. It must - * be OVER or SOURCE. - */ - void SetOperator(gfxContext::GraphicsOperator aOperator) - { - NS_ASSERTION(aOperator == gfxContext::OPERATOR_OVER || - aOperator == gfxContext::OPERATOR_SOURCE, - "Bad composition operator"); - mOperator = aOperator; - } - gfxContext::GraphicsOperator GetOperator() const { return mOperator; } - - bool GetClipToVisibleRegion() { return mClipToVisibleRegion; } - void SetClipToVisibleRegion(bool aClip) { mClipToVisibleRegion = aClip; } - - void SetDrawAtomically(bool aDrawAtomically) { mDrawAtomically = aDrawAtomically; } - -protected: - bool mHidden; - bool mClipToVisibleRegion; - bool mDrawAtomically; - gfxContext::GraphicsOperator mOperator; -}; - class AutoSetOperator { public: AutoSetOperator(gfxContext* aContext, gfxContext::GraphicsOperator aOperator) { @@ -2117,53 +2014,13 @@ BasicLayerManager::CreateReadbackLayer() return layer.forget(); } -class BasicShadowableThebesLayer; -class BasicShadowableLayer : public ShadowableLayer +BasicShadowableLayer::~BasicShadowableLayer() { -public: - BasicShadowableLayer() - { - MOZ_COUNT_CTOR(BasicShadowableLayer); + if (HasShadow()) { + PLayerChild::Send__delete__(GetShadow()); } - - ~BasicShadowableLayer() - { - if (HasShadow()) { - PLayerChild::Send__delete__(GetShadow()); - } - MOZ_COUNT_DTOR(BasicShadowableLayer); - } - - void SetShadow(PLayerChild* aShadow) - { - NS_ABORT_IF_FALSE(!mShadow, "can't have two shadows (yet)"); - mShadow = aShadow; - } - - virtual void SetBackBuffer(const SurfaceDescriptor& aBuffer) - { - NS_RUNTIMEABORT("if this default impl is called, |aBuffer| leaks"); - } - - virtual void SetBackBufferYUVImage(gfxSharedImageSurface* aYBuffer, - gfxSharedImageSurface* aUBuffer, - gfxSharedImageSurface* aVBuffer) - { - NS_RUNTIMEABORT("if this default impl is called, |aBuffer| leaks"); - } - - virtual void Disconnect() - { - // This is an "emergency Disconnect()", called when the compositing - // process has died. |mShadow| and our Shmem buffers are - // automatically managed by IPDL, so we don't need to explicitly - // free them here (it's hard to get that right on emergency - // shutdown anyway). - mShadow = nsnull; - } - - virtual BasicShadowableThebesLayer* AsThebes() { return nsnull; } -}; + MOZ_COUNT_DTOR(BasicShadowableLayer); +} static ShadowableLayer* ToShadowable(Layer* aLayer) diff --git a/gfx/layers/basic/BasicLayers.h b/gfx/layers/basic/BasicLayers.h index 3d2d94f9b39a..ba093ad49d2e 100644 --- a/gfx/layers/basic/BasicLayers.h +++ b/gfx/layers/basic/BasicLayers.h @@ -278,6 +278,49 @@ private: LayerRefArray mKeepAlive; }; +class BasicShadowableThebesLayer; +class BasicShadowableLayer : public ShadowableLayer +{ +public: + BasicShadowableLayer() + { + MOZ_COUNT_CTOR(BasicShadowableLayer); + } + + ~BasicShadowableLayer(); + + void SetShadow(PLayerChild* aShadow) + { + NS_ABORT_IF_FALSE(!mShadow, "can't have two shadows (yet)"); + mShadow = aShadow; + } + + virtual void SetBackBuffer(const SurfaceDescriptor& aBuffer) + { + NS_RUNTIMEABORT("if this default impl is called, |aBuffer| leaks"); + } + + virtual void SetBackBufferYUVImage(gfxSharedImageSurface* aYBuffer, + gfxSharedImageSurface* aUBuffer, + gfxSharedImageSurface* aVBuffer) + { + NS_RUNTIMEABORT("if this default impl is called, |aBuffer| leaks"); + } + + virtual void Disconnect() + { + // This is an "emergency Disconnect()", called when the compositing + // process has died. |mShadow| and our Shmem buffers are + // automatically managed by IPDL, so we don't need to explicitly + // free them here (it's hard to get that right on emergency + // shutdown anyway). + mShadow = nsnull; + } + + virtual BasicShadowableThebesLayer* AsThebes() { return nsnull; } +}; + + } }