mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1317843 - Split LayerManagerComposite into two classes. r=jrmuizel

This commit is contained in:
Bas Schouten 2016-11-24 18:11:27 +13:00
Родитель 5cd7f5c288
Коммит 56b7dd703d
25 изменённых файлов: 435 добавлений и 377 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

6
gfx/layers/LayerTreeInvalidation.cpp
Просмотреть файл

@ -479,9 +479,9 @@ public:
static ImageHost* GetImageHost(Layer* aLayer)
{
LayerComposite* composite = aLayer->AsLayerComposite();
if (composite) {
return static_cast<ImageHost*>(composite->GetCompositableHost());
HostLayer* compositor = aLayer->AsHostLayer();
if (compositor) {
return static_cast<ImageHost*>(compositor->GetCompositableHost());
}
return nullptr;
}

24
gfx/layers/Layers.cpp
Просмотреть файл

@ -576,7 +576,7 @@ Layer::CanUseOpaqueSurface()
const Maybe<ParentLayerIntRect>&
Layer::GetLocalClipRect()
{
if (LayerComposite* shadow = AsLayerComposite()) {
if (HostLayer* shadow = AsHostLayer()) {
return shadow->GetShadowClipRect();
}
return GetClipRect();
@ -585,7 +585,7 @@ Layer::GetLocalClipRect()
const LayerIntRegion&
Layer::GetLocalVisibleRegion()
{
if (LayerComposite* shadow = AsLayerComposite()) {
if (HostLayer* shadow = AsHostLayer()) {
return shadow->GetShadowVisibleRegion();
}
return GetVisibleRegion();
@ -782,7 +782,7 @@ Layer::CalculateScissorRect(const RenderTargetIntRect& aCurrentScissorRect)
}
if (GetLocalVisibleRegion().IsEmpty() &&
!(AsLayerComposite() && AsLayerComposite()->NeedToDrawCheckerboarding())) {
!(AsHostLayer() && AsHostLayer()->NeedToDrawCheckerboarding())) {
// When our visible region is empty, our parent may not have created the
// intermediate surface that we would require for correct clipping; however,
// this does not matter since we are invisible.
@ -887,7 +887,7 @@ Layer::GetTransformTyped() const
Matrix4x4
Layer::GetLocalTransform()
{
if (LayerComposite* shadow = AsLayerComposite())
if (HostLayer* shadow = AsHostLayer())
return shadow->GetShadowTransform();
else
return GetTransform();
@ -941,7 +941,7 @@ float
Layer::GetLocalOpacity()
{
float opacity = mOpacity;
if (LayerComposite* shadow = AsLayerComposite())
if (HostLayer* shadow = AsHostLayer())
opacity = shadow->GetShadowOpacity();
return std::min(std::max(opacity, 0.0f), 1.0f);
}
@ -1661,7 +1661,7 @@ LayerManager::BeginTabSwitch()
mTabSwitchStart = TimeStamp::Now();
}
static void PrintInfo(std::stringstream& aStream, LayerComposite* aLayerComposite);
static void PrintInfo(std::stringstream& aStream, HostLayer* aLayerComposite);
#ifdef MOZ_DUMP_PAINTING
template <typename T>
@ -1702,8 +1702,8 @@ Layer::Dump(std::stringstream& aStream, const char* aPrefix,
bool aDumpHtml, bool aSorted)
{
#ifdef MOZ_DUMP_PAINTING
bool dumpCompositorTexture = gfxEnv::DumpCompositorTextures() && AsLayerComposite() &&
AsLayerComposite()->GetCompositableHost();
bool dumpCompositorTexture = gfxEnv::DumpCompositorTextures() && AsHostLayer() &&
AsHostLayer()->GetCompositableHost();
bool dumpClientTexture = gfxEnv::DumpPaint() && AsShadowableLayer() &&
AsShadowableLayer()->GetCompositableClient();
nsCString layerId(Name());
@ -1723,7 +1723,7 @@ Layer::Dump(std::stringstream& aStream, const char* aPrefix,
#ifdef MOZ_DUMP_PAINTING
if (dumpCompositorTexture) {
AsLayerComposite()->GetCompositableHost()->Dump(aStream, aPrefix, aDumpHtml);
AsHostLayer()->GetCompositableHost()->Dump(aStream, aPrefix, aDumpHtml);
} else if (dumpClientTexture) {
if (aDumpHtml) {
aStream << nsPrintfCString(R"(<script>array["%s"]=")", layerId.BeginReading()).get();
@ -1886,7 +1886,7 @@ Layer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
aStream << aPrefix;
aStream << nsPrintfCString("%s%s (0x%p)", mManager->Name(), Name(), this).get();
layers::PrintInfo(aStream, AsLayerComposite());
layers::PrintInfo(aStream, AsHostLayer());
if (mClipRect) {
AppendToString(aStream, *mClipRect, " [clip=", "]");
@ -2030,7 +2030,7 @@ Layer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
layer->set_ptr(reinterpret_cast<uint64_t>(this));
layer->set_parentptr(reinterpret_cast<uint64_t>(aParent));
// Shadow
if (LayerComposite* lc = AsLayerComposite()) {
if (HostLayer* lc = AsHostLayer()) {
LayersPacket::Layer::Shadow* s = layer->mutable_shadow();
if (const Maybe<ParentLayerIntRect>& clipRect = lc->GetShadowClipRect()) {
DumpRect(s->mutable_clip(), *clipRect);
@ -2458,7 +2458,7 @@ LayerManager::ClearPendingScrollInfoUpdate()
}
void
PrintInfo(std::stringstream& aStream, LayerComposite* aLayerComposite)
PrintInfo(std::stringstream& aStream, HostLayer* aLayerComposite)
{
if (!aLayerComposite) {
return;

13
gfx/layers/Layers.h
Просмотреть файл

@ -89,7 +89,7 @@ class CanvasLayer;
class ReadbackLayer;
class ReadbackProcessor;
class RefLayer;
class LayerComposite;
class HostLayer;
class ShadowableLayer;
class ShadowLayerForwarder;
class LayerManagerComposite;
@ -1526,7 +1526,7 @@ public:
* Dynamic cast to a LayerComposite. Return null if this is not a
* LayerComposite. Can be used anytime.
*/
virtual LayerComposite* AsLayerComposite() { return nullptr; }
virtual HostLayer* AsHostLayer() { return nullptr; }
/**
* Dynamic cast to a ShadowableLayer. Return null if this is not a
@ -1946,6 +1946,13 @@ public:
*/
void SetAllowResidualTranslation(bool aAllow) { mAllowResidualTranslation = aAllow; }
void SetValidRegion(const nsIntRegion& aRegion)
{
MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ValidRegion", this));
mValidRegion = aRegion;
Mutated();
}
/**
* Can be used anytime
*/
@ -2371,6 +2378,8 @@ public:
*/
virtual void Initialize(const Data& aData) = 0;
void SetBounds(gfx::IntRect aBounds) { mBounds = aBounds; }
/**
* Check the data is owned by this layer is still valid for rendering
*/

36
gfx/layers/composite/AsyncCompositionManager.cpp
Просмотреть файл

@ -69,7 +69,7 @@ ContentMightReflowOnOrientationChange(const IntRect& rect)
return rect.width != rect.height;
}
AsyncCompositionManager::AsyncCompositionManager(LayerManagerComposite* aManager)
AsyncCompositionManager::AsyncCompositionManager(HostLayerManager* aManager)
: mLayerManager(aManager)
, mIsFirstPaint(true)
, mLayersUpdated(false)
@ -205,7 +205,7 @@ GetBaseTransform(Layer* aLayer, Matrix4x4* aTransform)
{
// Start with the animated transform if there is one
*aTransform =
(aLayer->AsLayerComposite()->GetShadowTransformSetByAnimation()
(aLayer->AsHostLayer()->GetShadowTransformSetByAnimation()
? aLayer->GetLocalTransform()
: aLayer->GetTransform());
}
@ -216,10 +216,10 @@ TransformClipRect(Layer* aLayer,
const ParentLayerToParentLayerMatrix4x4& aTransform)
{
MOZ_ASSERT(aTransform.Is2D());
const Maybe<ParentLayerIntRect>& clipRect = aLayer->AsLayerComposite()->GetShadowClipRect();
const Maybe<ParentLayerIntRect>& clipRect = aLayer->AsHostLayer()->GetShadowClipRect();
if (clipRect) {
ParentLayerIntRect transformed = TransformBy(aTransform, *clipRect);
aLayer->AsLayerComposite()->SetShadowClipRect(Some(transformed));
aLayer->AsHostLayer()->SetShadowClipRect(Some(transformed));
}
}
@ -233,7 +233,7 @@ TransformFixedClip(Layer* aLayer,
MOZ_ASSERT(aTransform.Is2D());
if (aClipParts.mFixedClip) {
*aClipParts.mFixedClip = TransformBy(aTransform, *aClipParts.mFixedClip);
aLayer->AsLayerComposite()->SetShadowClipRect(aClipParts.Intersect());
aLayer->AsHostLayer()->SetShadowClipRect(aClipParts.Intersect());
}
}
@ -256,7 +256,7 @@ SetShadowTransform(Layer* aLayer, LayerToParentLayerMatrix4x4 aTransform)
aTransform.PostScale(1.0f / aLayer->GetPostXScale(),
1.0f / aLayer->GetPostYScale(),
1);
aLayer->AsLayerComposite()->SetShadowBaseTransform(aTransform.ToUnknownMatrix());
aLayer->AsHostLayer()->SetShadowBaseTransform(aTransform.ToUnknownMatrix());
}
static void
@ -277,7 +277,7 @@ TranslateShadowLayer(Layer* aLayer,
layerTransform.PostTranslate(aTranslation);
SetShadowTransform(aLayer, layerTransform);
aLayer->AsLayerComposite()->SetShadowTransformSetByAnimation(false);
aLayer->AsHostLayer()->SetShadowTransformSetByAnimation(false);
if (aAdjustClipRect) {
auto transform = ParentLayerToParentLayerMatrix4x4::Translation(aTranslation);
@ -720,12 +720,12 @@ SampleAnimations(Layer* aLayer, TimeStamp aPoint)
animData.mEndValues.LastElement(),
computedTiming.mCurrentIteration,
&interpolatedValue, layer);
LayerComposite* layerComposite = layer->AsLayerComposite();
HostLayer* layerCompositor = layer->AsHostLayer();
switch (animation.property()) {
case eCSSProperty_opacity:
{
layerComposite->SetShadowOpacity(interpolatedValue.get_float());
layerComposite->SetShadowOpacitySetByAnimation(true);
layerCompositor->SetShadowOpacity(interpolatedValue.get_float());
layerCompositor->SetShadowOpacitySetByAnimation(true);
break;
}
case eCSSProperty_transform:
@ -734,8 +734,8 @@ SampleAnimations(Layer* aLayer, TimeStamp aPoint)
if (ContainerLayer* c = layer->AsContainerLayer()) {
matrix.PostScale(c->GetInheritedXScale(), c->GetInheritedYScale(), 1);
}
layerComposite->SetShadowBaseTransform(matrix);
layerComposite->SetShadowTransformSetByAnimation(true);
layerCompositor->SetShadowBaseTransform(matrix);
layerCompositor->SetShadowTransformSetByAnimation(true);
break;
}
default:
@ -779,7 +779,7 @@ AsyncCompositionManager::RecordShadowTransforms(Layer* aLayer)
if (!apzc) {
continue;
}
gfx::Matrix4x4 shadowTransform = layer->AsLayerComposite()->GetShadowBaseTransform();
gfx::Matrix4x4 shadowTransform = layer->AsHostLayer()->GetShadowBaseTransform();
if (!shadowTransform.Is2D()) {
continue;
}
@ -805,7 +805,7 @@ AdjustForClip(const AsyncTransformComponentMatrix& asyncTransform, Layer* aLayer
// then applying it to container as-is will produce incorrect results. To
// avoid this, translate the layer so that the clip rect starts at the origin,
// apply the tree transform, and translate back.
if (const Maybe<ParentLayerIntRect>& shadowClipRect = aLayer->AsLayerComposite()->GetShadowClipRect()) {
if (const Maybe<ParentLayerIntRect>& shadowClipRect = aLayer->AsHostLayer()->GetShadowClipRect()) {
if (shadowClipRect->TopLeft() != ParentLayerIntPoint()) { // avoid a gratuitous change of basis
result.ChangeBasis(shadowClipRect->x, shadowClipRect->y, 0);
}
@ -822,7 +822,7 @@ ExpandRootClipRect(Layer* aLayer, const ScreenMargin& aFixedLayerMargins)
// LayerView visible to the user is larger than the viewport size that Gecko
// knows about (and therefore larger than the clip rect). We could also just
// clear the clip rect on aLayer entirely but this seems more precise.
Maybe<ParentLayerIntRect> rootClipRect = aLayer->AsLayerComposite()->GetShadowClipRect();
Maybe<ParentLayerIntRect> rootClipRect = aLayer->AsHostLayer()->GetShadowClipRect();
if (rootClipRect && aFixedLayerMargins != ScreenMargin()) {
#ifndef MOZ_WIDGET_ANDROID
// We should never enter here on anything other than Fennec, since
@ -832,7 +832,7 @@ ExpandRootClipRect(Layer* aLayer, const ScreenMargin& aFixedLayerMargins)
ParentLayerRect rect(rootClipRect.value());
rect.Deflate(ViewAs<ParentLayerPixel>(aFixedLayerMargins,
PixelCastJustification::ScreenIsParentLayerForRoot));
aLayer->AsLayerComposite()->SetShadowClipRect(Some(RoundedOut(rect)));
aLayer->AsHostLayer()->SetShadowClipRect(Some(RoundedOut(rect)));
}
}
@ -1103,7 +1103,7 @@ AsyncCompositionManager::ApplyAsyncContentTransformToTree(Layer *aLayer,
// AlignFixedAndStickyLayers may overwrite this with a new clip it
// computes from the clip parts, but if that doesn't happen, this
// is the layer's final clip rect.
layer->AsLayerComposite()->SetShadowClipRect(clipParts.Intersect());
layer->AsHostLayer()->SetShadowClipRect(clipParts.Intersect());
}
if (hasAsyncTransform) {
@ -1439,7 +1439,7 @@ AsyncCompositionManager::TransformShadowTree(TimeStamp aCurrentFrame,
wantNextFrame |= SampleAPZAnimations(LayerMetricsWrapper(root), nextFrame);
}
LayerComposite* rootComposite = root->AsLayerComposite();
HostLayer* rootComposite = root->AsHostLayer();
gfx::Matrix4x4 trans = rootComposite->GetShadowBaseTransform();
trans *= gfx::Matrix4x4::From2D(mWorldTransform);

4
gfx/layers/composite/AsyncCompositionManager.h
Просмотреть файл

@ -70,7 +70,7 @@ class AsyncCompositionManager final
public:
NS_INLINE_DECL_REFCOUNTING(AsyncCompositionManager)
explicit AsyncCompositionManager(LayerManagerComposite* aManager);
explicit AsyncCompositionManager(HostLayerManager* aManager);
/**
* This forces the is-first-paint flag to true. This is intended to
@ -218,7 +218,7 @@ private:
TargetConfig mTargetConfig;
CSSRect mContentRect;
RefPtr<LayerManagerComposite> mLayerManager;
RefPtr<HostLayerManager> mLayerManager;
// When this flag is set, the next composition will be the first for a
// particular document (i.e. the document displayed on the screen will change).
// This happens when loading a new page or switching tabs. We notify the

2
gfx/layers/composite/CanvasLayerComposite.cpp
Просмотреть файл

@ -59,7 +59,7 @@ CanvasLayerComposite::GetLayer()
}
void
CanvasLayerComposite::SetLayerManager(LayerManagerComposite* aManager)
CanvasLayerComposite::SetLayerManager(HostLayerManager* aManager)
{
LayerComposite::SetLayerManager(aManager);
mManager = aManager;

6
gfx/layers/composite/CanvasLayerComposite.h
Просмотреть файл

@ -48,7 +48,7 @@ public:
Destroy();
}
virtual void SetLayerManager(LayerManagerComposite* aManager) override;
virtual void SetLayerManager(HostLayerManager* aManager) override;
virtual Layer* GetLayer() override;
virtual void RenderLayer(const gfx::IntRect& aClipRect) override;
@ -59,9 +59,7 @@ public:
CompositableHost* GetCompositableHost() override;
virtual LayerComposite* AsLayerComposite() override { return this; }
void SetBounds(gfx::IntRect aBounds) { mBounds = aBounds; }
virtual HostLayer* AsHostLayer() override { return this; }
virtual const char* Name() const override { return "CanvasLayerComposite"; }

4
gfx/layers/composite/ColorLayerComposite.h
Просмотреть файл

@ -39,7 +39,7 @@ public:
// LayerComposite Implementation
virtual Layer* GetLayer() override { return this; }
virtual void SetLayerManager(LayerManagerComposite* aManager) override
virtual void SetLayerManager(HostLayerManager* aManager) override
{
LayerComposite::SetLayerManager(aManager);
mManager = aManager;
@ -54,7 +54,7 @@ public:
CompositableHost* GetCompositableHost() override { return nullptr; }
virtual LayerComposite* AsLayerComposite() override { return this; }
virtual HostLayer* AsHostLayer() override { return this; }
virtual const char* Name() const override { return "ColorLayerComposite"; }
};

13
gfx/layers/composite/ContainerLayerComposite.cpp
Просмотреть файл

@ -97,7 +97,7 @@ static void PrintUniformityInfo(Layer* aLayer)
return;
}
Matrix4x4 transform = aLayer->AsLayerComposite()->GetShadowBaseTransform();
Matrix4x4 transform = aLayer->AsHostLayer()->GetShadowBaseTransform();
if (!transform.Is2D()) {
return;
}
@ -141,7 +141,7 @@ ContainerPrepare(ContainerT* aContainer,
aContainer->SortChildrenBy3DZOrder(children);
for (uint32_t i = 0; i < children.Length(); i++) {
LayerComposite* layerToRender = static_cast<LayerComposite*>(children.ElementAt(i)->ImplData());
LayerComposite* layerToRender = static_cast<LayerComposite*>(children.ElementAt(i)->AsHostLayer());
RenderTargetIntRect clipRect = layerToRender->GetLayer()->
CalculateScissorRect(aClipRect);
@ -606,7 +606,7 @@ ContainerLayerComposite::Destroy()
{
if (!mDestroyed) {
while (mFirstChild) {
static_cast<LayerComposite*>(GetFirstChild()->ImplData())->Destroy();
GetFirstChildComposite()->Destroy();
RemoveChild(mFirstChild);
}
mDestroyed = true;
@ -619,7 +619,7 @@ ContainerLayerComposite::GetFirstChildComposite()
if (!mFirstChild) {
return nullptr;
}
return static_cast<LayerComposite*>(mFirstChild->ImplData());
return static_cast<LayerComposite*>(mFirstChild->AsHostLayer());
}
void
@ -641,8 +641,7 @@ ContainerLayerComposite::CleanupResources()
mPrepared = nullptr;
for (Layer* l = GetFirstChild(); l; l = l->GetNextSibling()) {
LayerComposite* layerToCleanup = static_cast<LayerComposite*>(l->ImplData());
layerToCleanup->CleanupResources();
static_cast<LayerComposite*>(l->AsHostLayer())->CleanupResources();
}
}
@ -671,7 +670,7 @@ RefLayerComposite::GetFirstChildComposite()
if (!mFirstChild) {
return nullptr;
}
return static_cast<LayerComposite*>(mFirstChild->ImplData());
return static_cast<LayerComposite*>(mFirstChild->AsHostLayer());
}
void

8
gfx/layers/composite/ContainerLayerComposite.h
Просмотреть файл

@ -63,14 +63,14 @@ public:
// LayerComposite Implementation
virtual Layer* GetLayer() override { return this; }
virtual void SetLayerManager(LayerManagerComposite* aManager) override
virtual void SetLayerManager(HostLayerManager* aManager) override
{
LayerComposite::SetLayerManager(aManager);
mManager = aManager;
mLastIntermediateSurface = nullptr;
for (Layer* l = GetFirstChild(); l; l = l->GetNextSibling()) {
LayerComposite* child = l->AsLayerComposite();
HostLayer* child = l->AsHostLayer();
child->SetLayerManager(aManager);
}
}
@ -89,7 +89,7 @@ public:
virtual void CleanupResources() override;
virtual LayerComposite* AsLayerComposite() override { return this; }
virtual HostLayer* AsHostLayer() override { return this; }
// container layers don't use a compositable
CompositableHost* GetCompositableHost() override { return nullptr; }
@ -173,7 +173,7 @@ public:
virtual void CleanupResources() override;
virtual LayerComposite* AsLayerComposite() override { return this; }
virtual HostLayer* AsHostLayer() override { return this; }
// ref layers don't use a compositable
CompositableHost* GetCompositableHost() override { return nullptr; }

2
gfx/layers/composite/ImageHost.cpp
Просмотреть файл

@ -349,7 +349,7 @@ ImageHost::Composite(LayerComposite* aLayer,
if (mLastFrameID != img->mFrameID || mLastProducerID != img->mProducerID) {
if (mImageContainer) {
aLayer->GetLayerManager()->
static_cast<LayerManagerComposite*>(aLayer->GetLayerManager())->
AppendImageCompositeNotification(ImageCompositeNotification(
mImageContainer, nullptr,
img->mTimeStamp, GetCompositor()->GetCompositionTime(),

2
gfx/layers/composite/ImageLayerComposite.cpp
Просмотреть файл

@ -80,7 +80,7 @@ ImageLayerComposite::GetLayer()
}
void
ImageLayerComposite::SetLayerManager(LayerManagerComposite* aManager)
ImageLayerComposite::SetLayerManager(HostLayerManager* aManager)
{
LayerComposite::SetLayerManager(aManager);
mManager = aManager;

4
gfx/layers/composite/ImageLayerComposite.h
Просмотреть файл

@ -43,7 +43,7 @@ public:
virtual Layer* GetLayer() override;
virtual void SetLayerManager(LayerManagerComposite* aManager) override;
virtual void SetLayerManager(HostLayerManager* aManager) override;
virtual void RenderLayer(const gfx::IntRect& aClipRect) override;
@ -55,7 +55,7 @@ public:
virtual void GenEffectChain(EffectChain& aEffect) override;
virtual LayerComposite* AsLayerComposite() override { return this; }
virtual HostLayer* AsHostLayer() override { return this; }
virtual const char* Name() const override { return "ImageLayerComposite"; }

118
gfx/layers/composite/LayerManagerComposite.cpp
Просмотреть файл

@ -110,21 +110,27 @@ LayerManagerComposite::ClearCachedResources(Layer* aSubtree)
// Do we need that?
}
HostLayerManager::HostLayerManager()
: mDebugOverlayWantsNextFrame(false)
, mWarningLevel(0.0f)
, mWindowOverlayChanged(false)
, mLastPaintTime(TimeDuration::Forever())
, mRenderStartTime(TimeStamp::Now())
{}
HostLayerManager::~HostLayerManager()
{}
/**
* LayerManagerComposite
*/
LayerManagerComposite::LayerManagerComposite(Compositor* aCompositor)
: mWarningLevel(0.0f)
, mUnusedApzTransformWarning(false)
: mUnusedApzTransformWarning(false)
, mDisabledApzWarning(false)
, mCompositor(aCompositor)
, mInTransaction(false)
, mIsCompositorReady(false)
, mDebugOverlayWantsNextFrame(false)
, mGeometryChanged(true)
, mWindowOverlayChanged(false)
, mLastPaintTime(TimeDuration::Forever())
, mRenderStartTime(TimeStamp::Now())
{
mTextRenderer = new TextRenderer(aCompositor);
MOZ_ASSERT(aCompositor);
@ -232,7 +238,7 @@ LayerManagerComposite::PostProcessLayers(Layer* aLayer,
// Direct children of the establisher may have a clip, becaue the
// item containing it; ex. of nsHTMLScrollFrame, may give it one.
Maybe<ParentLayerIntRect> layerClip =
aLayer->AsLayerComposite()->GetShadowClipRect();
aLayer->AsHostLayer()->GetShadowClipRect();
Maybe<ParentLayerIntRect> ancestorClipForChildren =
IntersectMaybeRects(layerClip, aClipFromAncestors);
MOZ_ASSERT(!layerClip || !aLayer->Combines3DTransformWithAncestors(),
@ -266,7 +272,7 @@ LayerManagerComposite::PostProcessLayers(Layer* aLayer,
// Compute a clip that's the combination of our layer clip with the clip
// from our ancestors.
LayerComposite* composite = aLayer->AsLayerComposite();
LayerComposite* composite = static_cast<LayerComposite*>(aLayer->AsHostLayer());
Maybe<ParentLayerIntRect> layerClip = composite->GetShadowClipRect();
MOZ_ASSERT(!layerClip || !aLayer->Combines3DTransformWithAncestors(),
"The layer with a clip should not participate "
@ -495,47 +501,6 @@ LayerManagerComposite::CreateOptimalMaskDrawTarget(const IntSize &aSize)
return nullptr;
}
already_AddRefed<PaintedLayer>
LayerManagerComposite::CreatePaintedLayer()
{
MOZ_ASSERT(gIsGtest, "Unless you're testing the compositor using GTest,"
"this should only be called on the drawing side");
RefPtr<PaintedLayer> layer = new PaintedLayerComposite(this);
return layer.forget();
}
already_AddRefed<ContainerLayer>
LayerManagerComposite::CreateContainerLayer()
{
MOZ_ASSERT(gIsGtest, "Unless you're testing the compositor using GTest,"
"this should only be called on the drawing side");
RefPtr<ContainerLayer> layer = new ContainerLayerComposite(this);
return layer.forget();
}
already_AddRefed<ImageLayer>
LayerManagerComposite::CreateImageLayer()
{
NS_RUNTIMEABORT("Should only be called on the drawing side");
return nullptr;
}
already_AddRefed<ColorLayer>
LayerManagerComposite::CreateColorLayer()
{
MOZ_ASSERT(gIsGtest, "Unless you're testing the compositor using GTest,"
"this should only be called on the drawing side");
RefPtr<ColorLayer> layer = new ColorLayerComposite(this);
return layer.forget();
}
already_AddRefed<CanvasLayer>
LayerManagerComposite::CreateCanvasLayer()
{
NS_RUNTIMEABORT("Should only be called on the drawing side");
return nullptr;
}
LayerComposite*
LayerManagerComposite::RootLayer() const
{
@ -833,8 +798,8 @@ ClearLayerFlags(Layer* aLayer) {
aLayer,
[] (Layer* layer)
{
if (layer->AsLayerComposite()) {
layer->AsLayerComposite()->SetLayerComposited(false);
if (layer->AsHostLayer()) {
static_cast<LayerComposite*>(layer->AsHostLayer())->SetLayerComposited(false);
}
});
}
@ -1156,64 +1121,64 @@ LayerManagerComposite::RenderToPresentationSurface()
}
#endif
already_AddRefed<PaintedLayerComposite>
LayerManagerComposite::CreatePaintedLayerComposite()
already_AddRefed<PaintedLayer>
LayerManagerComposite::CreatePaintedLayer()
{
if (mDestroyed) {
NS_WARNING("Call on destroyed layer manager");
return nullptr;
}
return RefPtr<PaintedLayerComposite>(new PaintedLayerComposite(this)).forget();
return RefPtr<PaintedLayer>(new PaintedLayerComposite(this)).forget();
}
already_AddRefed<ContainerLayerComposite>
LayerManagerComposite::CreateContainerLayerComposite()
already_AddRefed<ContainerLayer>
LayerManagerComposite::CreateContainerLayer()
{
if (mDestroyed) {
NS_WARNING("Call on destroyed layer manager");
return nullptr;
}
return RefPtr<ContainerLayerComposite>(new ContainerLayerComposite(this)).forget();
return RefPtr<ContainerLayer>(new ContainerLayerComposite(this)).forget();
}
already_AddRefed<ImageLayerComposite>
LayerManagerComposite::CreateImageLayerComposite()
already_AddRefed<ImageLayer>
LayerManagerComposite::CreateImageLayer()
{
if (mDestroyed) {
NS_WARNING("Call on destroyed layer manager");
return nullptr;
}
return RefPtr<ImageLayerComposite>(new ImageLayerComposite(this)).forget();
return RefPtr<ImageLayer>(new ImageLayerComposite(this)).forget();
}
already_AddRefed<ColorLayerComposite>
LayerManagerComposite::CreateColorLayerComposite()
already_AddRefed<ColorLayer>
LayerManagerComposite::CreateColorLayer()
{
if (LayerManagerComposite::mDestroyed) {
NS_WARNING("Call on destroyed layer manager");
return nullptr;
}
return RefPtr<ColorLayerComposite>(new ColorLayerComposite(this)).forget();
return RefPtr<ColorLayer>(new ColorLayerComposite(this)).forget();
}
already_AddRefed<CanvasLayerComposite>
LayerManagerComposite::CreateCanvasLayerComposite()
already_AddRefed<CanvasLayer>
LayerManagerComposite::CreateCanvasLayer()
{
if (LayerManagerComposite::mDestroyed) {
NS_WARNING("Call on destroyed layer manager");
return nullptr;
}
return RefPtr<CanvasLayerComposite>(new CanvasLayerComposite(this)).forget();
return RefPtr<CanvasLayer>(new CanvasLayerComposite(this)).forget();
}
already_AddRefed<RefLayerComposite>
LayerManagerComposite::CreateRefLayerComposite()
already_AddRefed<RefLayer>
LayerManagerComposite::CreateRefLayer()
{
if (LayerManagerComposite::mDestroyed) {
NS_WARNING("Call on destroyed layer manager");
return nullptr;
}
return RefPtr<RefLayerComposite>(new RefLayerComposite(this)).forget();
return RefPtr<RefLayer>(new RefLayerComposite(this)).forget();
}
LayerManagerComposite::AutoAddMaskEffect::AutoAddMaskEffect(Layer* aMaskLayer,
@ -1255,11 +1220,9 @@ LayerManagerComposite::ChangeCompositor(Compositor* aNewCompositor)
}
LayerComposite::LayerComposite(LayerManagerComposite *aManager)
: mCompositeManager(aManager)
: HostLayer(aManager)
, mCompositeManager(aManager)
, mCompositor(aManager->GetCompositor())
, mShadowOpacity(1.0)
, mShadowTransformSetByAnimation(false)
, mShadowOpacitySetByAnimation(false)
, mDestroyed(false)
, mLayerComposited(false)
{ }
@ -1305,10 +1268,11 @@ LayerManagerComposite::NotifyShadowTreeTransaction()
}
void
LayerComposite::SetLayerManager(LayerManagerComposite* aManager)
LayerComposite::SetLayerManager(HostLayerManager* aManager)
{
mCompositeManager = aManager;
mCompositor = aManager->GetCompositor();
HostLayer::SetLayerManager(aManager);
mCompositeManager = static_cast<LayerManagerComposite*>(aManager);
mCompositor = mCompositeManager->GetCompositor();
}
bool
@ -1336,7 +1300,7 @@ LayerComposite::GetFullyRenderedRegion() {
}
Matrix4x4
LayerComposite::GetShadowTransform() {
HostLayer::GetShadowTransform() {
Matrix4x4 transform = mShadowTransform;
Layer* layer = GetLayer();

395
gfx/layers/composite/LayerManagerComposite.h
Просмотреть файл

@ -65,7 +65,121 @@ class PaintCounter;
static const int kVisualWarningDuration = 150; // ms
class LayerManagerComposite final : public LayerManager
// An implementation of LayerManager that acts as a pair with ClientLayerManager
// and is mirrored across IPDL. This gets managed/updated by LayerTransactionParent.
class HostLayerManager : public LayerManager
{
public:
HostLayerManager();
~HostLayerManager();
virtual bool BeginTransactionWithTarget(gfxContext* aTarget) override
{
MOZ_CRASH("GFX: Use BeginTransactionWithDrawTarget");
}
virtual bool EndEmptyTransaction(EndTransactionFlags aFlags = END_DEFAULT) override
{
MOZ_CRASH("GFX: Use EndTransaction(aTimeStamp)");
return false;
}
virtual void EndTransaction(DrawPaintedLayerCallback aCallback,
void* aCallbackData,
EndTransactionFlags aFlags = END_DEFAULT) override
{
MOZ_CRASH("GFX: Use EndTransaction(aTimeStamp)");
}
virtual int32_t GetMaxTextureSize() const override
{
MOZ_CRASH("GFX: Call on compositor, not LayerManagerComposite");
}
virtual LayersBackend GetBackendType() override
{
MOZ_CRASH("GFX: Shouldn't be called for composited layer manager");
}
virtual void GetBackendName(nsAString& name) override
{
MOZ_CRASH("GFX: Shouldn't be called for composited layer manager");
}
virtual TextureFactoryIdentifier GetTextureFactoryIdentifier() = 0;
virtual void ForcePresent() = 0;
virtual void AddInvalidRegion(const nsIntRegion& aRegion) = 0;
virtual void ClearApproximatelyVisibleRegions(uint64_t aLayersId,
const Maybe<uint32_t>& aPresShellId) = 0;
virtual void UpdateApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
const CSSIntRegion& aRegion) = 0;
virtual void NotifyShadowTreeTransaction() {}
virtual void BeginTransactionWithDrawTarget(gfx::DrawTarget* aTarget,
const gfx::IntRect& aRect) = 0;
virtual Compositor* GetCompositor() const = 0;
virtual void EndTransaction(const TimeStamp& aTimeStamp,
EndTransactionFlags aFlags = END_DEFAULT) = 0;
virtual void UpdateRenderBounds(const gfx::IntRect& aRect) {}
// Called by CompositorBridgeParent when a new compositor has been created due
// to a device reset. The layer manager must clear any cached resources
// attached to the old compositor, and make a best effort at ignoring
// layer or texture updates against the old compositor.
virtual void ChangeCompositor(Compositor* aNewCompositor) = 0;
void ExtractImageCompositeNotifications(nsTArray<ImageCompositeNotification>* aNotifications)
{
aNotifications->AppendElements(Move(mImageCompositeNotifications));
}
/**
* LayerManagerComposite provides sophisticated debug overlays
* that can request a next frame.
*/
bool DebugOverlayWantsNextFrame() { return mDebugOverlayWantsNextFrame; }
void SetDebugOverlayWantsNextFrame(bool aVal)
{ mDebugOverlayWantsNextFrame = aVal; }
/**
* Add an on frame warning.
* @param severity ranges from 0 to 1. It's used to compute the warning color.
*/
void VisualFrameWarning(float severity) {
mozilla::TimeStamp now = TimeStamp::Now();
if (mWarnTime.IsNull() ||
severity > mWarningLevel ||
mWarnTime + TimeDuration::FromMilliseconds(kVisualWarningDuration) < now) {
mWarnTime = now;
mWarningLevel = severity;
}
}
// Indicate that we need to composite even if nothing in our layers has
// changed, so that the widget can draw something different in its window
// overlay.
void SetWindowOverlayChanged() { mWindowOverlayChanged = true; }
void SetPaintTime(const TimeDuration& aPaintTime) { mLastPaintTime = aPaintTime; }
protected:
bool mDebugOverlayWantsNextFrame;
nsTArray<ImageCompositeNotification> mImageCompositeNotifications;
// Testing property. If hardware composer is supported, this will return
// true if the last frame was deemed 'too complicated' to be rendered.
float mWarningLevel;
mozilla::TimeStamp mWarnTime;
bool mWindowOverlayChanged;
RefPtr<PaintCounter> mPaintCounter;
TimeDuration mLastPaintTime;
TimeStamp mRenderStartTime;
};
// A layer manager implementation that uses the Compositor API
// to render layers.
class LayerManagerComposite final : public HostLayerManager
{
typedef mozilla::gfx::DrawTarget DrawTarget;
typedef mozilla::gfx::IntSize IntSize;
@ -99,30 +213,19 @@ public:
return this;
}
void UpdateRenderBounds(const gfx::IntRect& aRect);
void UpdateRenderBounds(const gfx::IntRect& aRect) override;
virtual bool BeginTransaction() override;
virtual bool BeginTransactionWithTarget(gfxContext* aTarget) override
{
MOZ_CRASH("GFX: Use BeginTransactionWithDrawTarget");
return false;
}
void BeginTransactionWithDrawTarget(gfx::DrawTarget* aTarget,
const gfx::IntRect& aRect);
virtual bool EndEmptyTransaction(EndTransactionFlags aFlags = END_DEFAULT) override
{
MOZ_CRASH("GFX: Use EndTransaction(aTimeStamp)");
return false;
}
const gfx::IntRect& aRect) override;
void EndTransaction(const TimeStamp& aTimeStamp,
EndTransactionFlags aFlags = END_DEFAULT) override;
virtual void EndTransaction(DrawPaintedLayerCallback aCallback,
void* aCallbackData,
EndTransactionFlags aFlags = END_DEFAULT) override
{
MOZ_CRASH("GFX: Use EndTransaction(aTimeStamp)");
}
void EndTransaction(const TimeStamp& aTimeStamp,
EndTransactionFlags aFlags = END_DEFAULT);
virtual void SetRoot(Layer* aLayer) override { mRoot = aLayer; }
@ -130,11 +233,6 @@ public:
// (bug 946926).
virtual bool CanUseCanvasLayerForSize(const gfx::IntSize &aSize) override;
virtual int32_t GetMaxTextureSize() const override
{
MOZ_CRASH("GFX: Call on compositor, not LayerManagerComposite");
}
virtual void ClearCachedResources(Layer* aSubtree = nullptr) override;
virtual already_AddRefed<PaintedLayer> CreatePaintedLayer() override;
@ -142,21 +240,7 @@ public:
virtual already_AddRefed<ImageLayer> CreateImageLayer() override;
virtual already_AddRefed<ColorLayer> CreateColorLayer() override;
virtual already_AddRefed<CanvasLayer> CreateCanvasLayer() override;
already_AddRefed<PaintedLayerComposite> CreatePaintedLayerComposite();
already_AddRefed<ContainerLayerComposite> CreateContainerLayerComposite();
already_AddRefed<ImageLayerComposite> CreateImageLayerComposite();
already_AddRefed<ColorLayerComposite> CreateColorLayerComposite();
already_AddRefed<CanvasLayerComposite> CreateCanvasLayerComposite();
already_AddRefed<RefLayerComposite> CreateRefLayerComposite();
virtual LayersBackend GetBackendType() override
{
MOZ_CRASH("GFX: Shouldn't be called for composited layer manager");
}
virtual void GetBackendName(nsAString& name) override
{
MOZ_CRASH("GFX: Shouldn't be called for composited layer manager");
}
virtual already_AddRefed<RefLayer> CreateRefLayer() override;
virtual bool AreComponentAlphaLayersEnabled() override;
@ -207,13 +291,13 @@ public:
static void PlatformSyncBeforeReplyUpdate();
void AddInvalidRegion(const nsIntRegion& aRegion)
void AddInvalidRegion(const nsIntRegion& aRegion) override
{
mInvalidRegion.Or(mInvalidRegion, aRegion);
}
void ClearApproximatelyVisibleRegions(uint64_t aLayersId,
const Maybe<uint32_t>& aPresShellId)
const Maybe<uint32_t>& aPresShellId) override
{
for (auto iter = mVisibleRegions.Iter(); !iter.Done(); iter.Next()) {
if (iter.Key().mLayersId == aLayersId &&
@ -224,7 +308,7 @@ public:
}
void UpdateApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
const CSSIntRegion& aRegion)
const CSSIntRegion& aRegion) override
{
CSSIntRegion* regionForScrollFrame = mVisibleRegions.LookupOrAdd(aGuid);
MOZ_ASSERT(regionForScrollFrame);
@ -237,7 +321,7 @@ public:
return mVisibleRegions.Get(aGuid);
}
Compositor* GetCompositor() const
Compositor* GetCompositor() const override
{
return mCompositor;
}
@ -246,34 +330,12 @@ public:
// to a device reset. The layer manager must clear any cached resources
// attached to the old compositor, and make a best effort at ignoring
// layer or texture updates against the old compositor.
void ChangeCompositor(Compositor* aNewCompositor);
void ChangeCompositor(Compositor* aNewCompositor) override;
/**
* LayerManagerComposite provides sophisticated debug overlays
* that can request a next frame.
*/
bool DebugOverlayWantsNextFrame() { return mDebugOverlayWantsNextFrame; }
void SetDebugOverlayWantsNextFrame(bool aVal)
{ mDebugOverlayWantsNextFrame = aVal; }
void NotifyShadowTreeTransaction();
void NotifyShadowTreeTransaction() override;
TextRenderer* GetTextRenderer() { return mTextRenderer; }
/**
* Add an on frame warning.
* @param severity ranges from 0 to 1. It's used to compute the warning color.
*/
void VisualFrameWarning(float severity) {
mozilla::TimeStamp now = TimeStamp::Now();
if (mWarnTime.IsNull() ||
severity > mWarningLevel ||
mWarnTime + TimeDuration::FromMilliseconds(kVisualWarningDuration) < now) {
mWarnTime = now;
mWarningLevel = severity;
}
}
void UnusedApzTransformWarning() {
mUnusedApzTransformWarning = true;
}
@ -294,19 +356,12 @@ public:
mImageCompositeNotifications.AppendElement(aNotification);
}
}
void ExtractImageCompositeNotifications(nsTArray<ImageCompositeNotification>* aNotifications)
virtual TextureFactoryIdentifier GetTextureFactoryIdentifier() override
{
aNotifications->AppendElements(Move(mImageCompositeNotifications));
return mCompositor->GetTextureFactoryIdentifier();
}
// Indicate that we need to composite even if nothing in our layers has
// changed, so that the widget can draw something different in its window
// overlay.
void SetWindowOverlayChanged() { mWindowOverlayChanged = true; }
void ForcePresent() { mCompositor->ForcePresent(); }
void SetPaintTime(const TimeDuration& aPaintTime) { mLastPaintTime = aPaintTime; }
void ForcePresent() override { mCompositor->ForcePresent(); }
private:
/** Region we're clipping our current drawing to. */
@ -354,15 +409,11 @@ private:
void ChangeCompositorInternal(Compositor* aNewCompositor);
float mWarningLevel;
mozilla::TimeStamp mWarnTime;
bool mUnusedApzTransformWarning;
bool mDisabledApzWarning;
RefPtr<Compositor> mCompositor;
UniquePtr<LayerProperties> mClonedLayerTreeProperties;
nsTArray<ImageCompositeNotification> mImageCompositeNotifications;
/**
* Context target, nullptr when drawing directly to our swap chain.
*/
@ -379,70 +430,44 @@ private:
bool mInTransaction;
bool mIsCompositorReady;
bool mDebugOverlayWantsNextFrame;
RefPtr<CompositingRenderTarget> mTwoPassTmpTarget;
RefPtr<TextRenderer> mTextRenderer;
bool mGeometryChanged;
bool mWindowOverlayChanged;
RefPtr<PaintCounter> mPaintCounter;
TimeDuration mLastPaintTime;
TimeStamp mRenderStartTime;
};
/**
* Composite layers are for use with OMTC on the compositor thread only. There
* must be corresponding Basic layers on the content thread. For composite
* layers, the layer manager only maintains the layer tree, all rendering is
* done by a Compositor (see Compositor.h). As such, composite layers are
* platform-independent and can be used on any platform for which there is a
* Compositor implementation.
*
* The composite layer tree reflects exactly the basic layer tree. To
* composite to screen, the layer manager walks the layer tree calling render
* methods which in turn call into their CompositableHosts' Composite methods.
* These call Compositor::DrawQuad to do the rendering.
*
* Mostly, layers are updated during the layers transaction. This is done from
* CompositableClient to CompositableHost without interacting with the layer.
*
* A reference to the Compositor is stored in LayerManagerComposite.
* Compositor layers are for use with OMTC on the compositor thread only. There
* must be corresponding Client layers on the content thread. For composite
* layers, the layer manager only maintains the layer tree.
*/
class LayerComposite
class HostLayer
{
public:
explicit LayerComposite(LayerManagerComposite* aManager);
explicit HostLayer(HostLayerManager* aManager)
: mCompositorManager(aManager)
, mShadowOpacity(1.0)
, mShadowTransformSetByAnimation(false)
, mShadowOpacitySetByAnimation(false)
{
}
virtual ~LayerComposite();
virtual void SetLayerManager(HostLayerManager* aManager)
{
mCompositorManager = aManager;
}
HostLayerManager* GetLayerManager() const { return mCompositorManager; }
virtual ~HostLayer() {}
virtual LayerComposite* GetFirstChildComposite()
{
return nullptr;
}
/* Do NOT call this from the generic LayerComposite destructor. Only from the
* concrete class destructor
*/
virtual void Destroy();
virtual Layer* GetLayer() = 0;
virtual void SetLayerManager(LayerManagerComposite* aManager);
LayerManagerComposite* GetLayerManager() const { return mCompositeManager; }
/**
* Perform a first pass over the layer tree to render all of the intermediate
* surfaces that we can. This allows us to avoid framebuffer switches in the
* middle of our render which is inefficient especially on mobile GPUs. This
* must be called before RenderLayer.
*/
virtual void Prepare(const RenderTargetIntRect& aClipRect) {}
// TODO: This should also take RenderTargetIntRect like Prepare.
virtual void RenderLayer(const gfx::IntRect& aClipRect) = 0;
virtual bool SetCompositableHost(CompositableHost*)
{
// We must handle this gracefully, see bug 967824
@ -451,14 +476,6 @@ public:
}
virtual CompositableHost* GetCompositableHost() = 0;
virtual void CleanupResources() = 0;
virtual void DestroyFrontBuffer() { }
void AddBlendModeEffect(EffectChain& aEffectChain);
virtual void GenEffectChain(EffectChain& aEffect) { }
/**
* The following methods are
*
@ -494,6 +511,95 @@ public:
mShadowTransformSetByAnimation = aSetByAnimation;
}
// These getters can be used anytime.
float GetShadowOpacity() { return mShadowOpacity; }
const Maybe<ParentLayerIntRect>& GetShadowClipRect() { return mShadowClipRect; }
const LayerIntRegion& GetShadowVisibleRegion() { return mShadowVisibleRegion; }
const gfx::Matrix4x4& GetShadowBaseTransform() { return mShadowTransform; }
gfx::Matrix4x4 GetShadowTransform();
bool GetShadowTransformSetByAnimation() { return mShadowTransformSetByAnimation; }
bool GetShadowOpacitySetByAnimation() { return mShadowOpacitySetByAnimation; }
/**
* Return true if a checkerboarding background color needs to be drawn
* for this layer.
*/
virtual bool NeedToDrawCheckerboarding(gfx::Color* aOutCheckerboardingColor = nullptr) { return false; }
protected:
HostLayerManager* mCompositorManager;
gfx::Matrix4x4 mShadowTransform;
LayerIntRegion mShadowVisibleRegion;
Maybe<ParentLayerIntRect> mShadowClipRect;
float mShadowOpacity;
bool mShadowTransformSetByAnimation;
bool mShadowOpacitySetByAnimation;
};
/**
* Composite layers are for use with OMTC on the compositor thread only. There
* must be corresponding Client layers on the content thread. For composite
* layers, the layer manager only maintains the layer tree, all rendering is
* done by a Compositor (see Compositor.h). As such, composite layers are
* platform-independent and can be used on any platform for which there is a
* Compositor implementation.
*
* The composite layer tree reflects exactly the basic layer tree. To
* composite to screen, the layer manager walks the layer tree calling render
* methods which in turn call into their CompositableHosts' Composite methods.
* These call Compositor::DrawQuad to do the rendering.
*
* Mostly, layers are updated during the layers transaction. This is done from
* CompositableClient to CompositableHost without interacting with the layer.
*
* A reference to the Compositor is stored in LayerManagerComposite.
*/
class LayerComposite : public HostLayer
{
public:
explicit LayerComposite(LayerManagerComposite* aManager);
virtual ~LayerComposite();
virtual void SetLayerManager(HostLayerManager* aManager);
virtual LayerComposite* GetFirstChildComposite()
{
return nullptr;
}
/* Do NOT call this from the generic LayerComposite destructor. Only from the
* concrete class destructor
*/
virtual void Destroy();
/**
* Perform a first pass over the layer tree to render all of the intermediate
* surfaces that we can. This allows us to avoid framebuffer switches in the
* middle of our render which is inefficient especially on mobile GPUs. This
* must be called before RenderLayer.
*/
virtual void Prepare(const RenderTargetIntRect& aClipRect) {}
// TODO: This should also take RenderTargetIntRect like Prepare.
virtual void RenderLayer(const gfx::IntRect& aClipRect) = 0;
virtual bool SetCompositableHost(CompositableHost*)
{
// We must handle this gracefully, see bug 967824
NS_WARNING("called SetCompositableHost for a layer type not accepting a compositable");
return false;
}
virtual void CleanupResources() = 0;
virtual void DestroyFrontBuffer() { }
void AddBlendModeEffect(EffectChain& aEffectChain);
virtual void GenEffectChain(EffectChain& aEffect) { }
void SetLayerComposited(bool value)
{
mLayerComposited = value;
@ -504,14 +610,6 @@ public:
mClearRect = aRect;
}
// These getters can be used anytime.
float GetShadowOpacity() { return mShadowOpacity; }
const Maybe<ParentLayerIntRect>& GetShadowClipRect() { return mShadowClipRect; }
const LayerIntRegion& GetShadowVisibleRegion() { return mShadowVisibleRegion; }
const gfx::Matrix4x4& GetShadowBaseTransform() { return mShadowTransform; }
gfx::Matrix4x4 GetShadowTransform();
bool GetShadowTransformSetByAnimation() { return mShadowTransformSetByAnimation; }
bool GetShadowOpacitySetByAnimation() { return mShadowOpacitySetByAnimation; }
bool HasLayerBeenComposited() { return mLayerComposited; }
gfx::IntRect GetClearRect() { return mClearRect; }
@ -525,21 +623,12 @@ public:
*/
virtual nsIntRegion GetFullyRenderedRegion();
/**
* Return true if a checkerboarding background color needs to be drawn
* for this layer.
*/
bool NeedToDrawCheckerboarding(gfx::Color* aOutCheckerboardingColor = nullptr);
virtual bool NeedToDrawCheckerboarding(gfx::Color* aOutCheckerboardingColor = nullptr);
protected:
gfx::Matrix4x4 mShadowTransform;
LayerIntRegion mShadowVisibleRegion;
Maybe<ParentLayerIntRect> mShadowClipRect;
LayerManagerComposite* mCompositeManager;
RefPtr<Compositor> mCompositor;
float mShadowOpacity;
bool mShadowTransformSetByAnimation;
bool mShadowOpacitySetByAnimation;
bool mDestroyed;
bool mLayerComposited;
gfx::IntRect mClearRect;
@ -556,7 +645,7 @@ protected:
// aRenderCallback is called exactly once, inside this function, unless aLayer's
// visible region is completely clipped out (in that case, aRenderCallback won't
// be called at all).
// This function calls aLayer->AsLayerComposite()->AddBlendModeEffect for the
// This function calls aLayer->AsHostLayer()->AddBlendModeEffect for the
// final rendering pass.
//
// (This function should really live in LayerManagerComposite.cpp, but we
@ -589,7 +678,7 @@ RenderWithAllMasks(Layer* aLayer, Compositor* aCompositor,
EffectChain effectChain(aLayer);
LayerManagerComposite::AutoAddMaskEffect
autoMaskEffect(firstMask, effectChain);
aLayer->AsLayerComposite()->AddBlendModeEffect(effectChain);
static_cast<LayerComposite*>(aLayer->AsHostLayer())->AddBlendModeEffect(effectChain);
aRenderCallback(effectChain, aClipRect);
return;
}
@ -665,7 +754,7 @@ RenderWithAllMasks(Layer* aLayer, Compositor* aCompositor,
// The blend mode needs to be applied in this final step, because this is
// where we're blending with the actual background (which is in originalTarget).
aLayer->AsLayerComposite()->AddBlendModeEffect(finalEffectChain);
static_cast<LayerComposite*>(aLayer->AsHostLayer())->AddBlendModeEffect(finalEffectChain);
LayerManagerComposite::AutoAddMaskEffect autoMaskEffect(finalMask, finalEffectChain);
if (!autoMaskEffect.Failed()) {
aCompositor->DrawQuad(gfx::Rect(surfaceRect), aClipRect,

2
gfx/layers/composite/PaintedLayerComposite.cpp
Просмотреть файл

@ -79,7 +79,7 @@ PaintedLayerComposite::GetLayer()
}
void
PaintedLayerComposite::SetLayerManager(LayerManagerComposite* aManager)
PaintedLayerComposite::SetLayerManager(HostLayerManager* aManager)
{
LayerComposite::SetLayerManager(aManager);
mManager = aManager;

11
gfx/layers/composite/PaintedLayerComposite.h
Просмотреть файл

@ -49,7 +49,7 @@ public:
virtual Layer* GetLayer() override;
virtual void SetLayerManager(LayerManagerComposite* aManager) override;
virtual void SetLayerManager(HostLayerManager* aManager) override;
virtual void RenderLayer(const gfx::IntRect& aClipRect) override;
@ -59,20 +59,13 @@ public:
virtual bool SetCompositableHost(CompositableHost* aHost) override;
virtual LayerComposite* AsLayerComposite() override { return this; }
virtual HostLayer* AsHostLayer() override { return this; }
virtual void InvalidateRegion(const nsIntRegion& aRegion) override
{
NS_RUNTIMEABORT("PaintedLayerComposites can't fill invalidated regions");
}
void SetValidRegion(const nsIntRegion& aRegion)
{
MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ValidRegion", this));
mValidRegion = aRegion;
Mutated();
}
const virtual gfx::TiledIntRegion& GetInvalidRegion() override;
MOZ_LAYER_DECL_NAME("PaintedLayerComposite", TYPE_PAINTED)

22
gfx/layers/ipc/CompositorBridgeParent.cpp
Просмотреть файл

@ -855,14 +855,14 @@ CompositorBridgeParent::SetShadowProperties(Layer* aLayer)
}
// FIXME: Bug 717688 -- Do these updates in LayerTransactionParent::RecvUpdate.
LayerComposite* layerComposite = layer->AsLayerComposite();
HostLayer* layerCompositor = layer->AsHostLayer();
// Set the layerComposite's base transform to the layer's base transform.
layerComposite->SetShadowBaseTransform(layer->GetBaseTransform());
layerComposite->SetShadowTransformSetByAnimation(false);
layerComposite->SetShadowVisibleRegion(layer->GetVisibleRegion());
layerComposite->SetShadowClipRect(layer->GetClipRect());
layerComposite->SetShadowOpacity(layer->GetOpacity());
layerComposite->SetShadowOpacitySetByAnimation(false);
layerCompositor->SetShadowBaseTransform(layer->GetBaseTransform());
layerCompositor->SetShadowTransformSetByAnimation(false);
layerCompositor->SetShadowVisibleRegion(layer->GetVisibleRegion());
layerCompositor->SetShadowClipRect(layer->GetClipRect());
layerCompositor->SetShadowOpacity(layer->GetOpacity());
layerCompositor->SetShadowOpacitySetByAnimation(false);
}
);
}
@ -1159,7 +1159,9 @@ CompositorBridgeParent::ShadowLayersUpdated(LayerTransactionParent* aLayerTree,
// race condition.
mLayerManager->UpdateRenderBounds(aTargetConfig.naturalBounds());
mLayerManager->SetRegionToClear(aTargetConfig.clearRegion());
mLayerManager->GetCompositor()->SetScreenRotation(aTargetConfig.rotation());
if (mLayerManager->GetCompositor()) {
mLayerManager->GetCompositor()->SetScreenRotation(aTargetConfig.rotation());
}
mCompositionManager->Updated(aIsFirstPaint, aTargetConfig, aPaintSyncId);
Layer* root = aLayerTree->GetRoot();
@ -1425,7 +1427,7 @@ CompositorBridgeParent::AllocPLayerTransactionParent(const nsTArray<LayersBacken
mCompositionManager = new AsyncCompositionManager(mLayerManager);
*aSuccess = true;
*aTextureFactoryIdentifier = mCompositor->GetTextureFactoryIdentifier();
*aTextureFactoryIdentifier = mLayerManager->GetTextureFactoryIdentifier();
LayerTransactionParent* p = new LayerTransactionParent(mLayerManager, this, 0);
p->AddIPDLReference();
return p;
@ -1527,7 +1529,7 @@ CompositorBridgeParent::RecvAdoptChild(const uint64_t& child)
sIndirectLayerTrees[child].mLayerTree->mLayerManager = mLayerManager;
}
if (sIndirectLayerTrees[child].mRoot) {
sIndirectLayerTrees[child].mRoot->AsLayerComposite()->SetLayerManager(mLayerManager);
sIndirectLayerTrees[child].mRoot->AsHostLayer()->SetLayerManager(static_cast<HostLayerManager*>(mLayerManager.get()));
}
parent = sIndirectLayerTrees[child].mApzcTreeManagerParent;
}

6
gfx/layers/ipc/CompositorBridgeParent.h
Просмотреть файл

@ -64,7 +64,7 @@ class AsyncCompositionManager;
class Compositor;
class CompositorBridgeParent;
class CompositorVsyncScheduler;
class LayerManagerComposite;
class HostLayerManager;
class LayerTransactionParent;
class PAPZParent;
class CrossProcessCompositorBridgeParent;
@ -359,7 +359,7 @@ public:
RefPtr<GeckoContentController> mController;
APZCTreeManagerParent* mApzcTreeManagerParent;
RefPtr<CompositorBridgeParent> mParent;
LayerManagerComposite* mLayerManager;
HostLayerManager* mLayerManager;
// Pointer to the CrossProcessCompositorBridgeParent. Used by APZCs to share
// their FrameMetrics with the corresponding child process that holds
// the PCompositorBridgeChild
@ -547,7 +547,7 @@ protected:
template <typename Lambda>
inline void ForEachIndirectLayerTree(const Lambda& aCallback);
RefPtr<LayerManagerComposite> mLayerManager;
RefPtr<HostLayerManager> mLayerManager;
RefPtr<Compositor> mCompositor;
RefPtr<AsyncCompositionManager> mCompositionManager;
widget::CompositorWidget* mWidget;

2
gfx/layers/ipc/CrossProcessCompositorBridgeParent.cpp
Просмотреть файл

@ -80,7 +80,7 @@ CrossProcessCompositorBridgeParent::AllocPLayerTransactionParent(
if (state && state->mLayerManager) {
state->mCrossProcessParent = this;
LayerManagerComposite* lm = state->mLayerManager;
HostLayerManager* lm = state->mLayerManager;
*aTextureFactoryIdentifier = lm->GetCompositor()->GetTextureFactoryIdentifier();
*aSuccess = true;
LayerTransactionParent* p = new LayerTransactionParent(lm, this, aId);

62
gfx/layers/ipc/LayerTransactionParent.cpp
Просмотреть файл

@ -140,7 +140,7 @@ ShadowChild(const OpRaiseToTopChild& op)
//--------------------------------------------------
// LayerTransactionParent
LayerTransactionParent::LayerTransactionParent(LayerManagerComposite* aManager,
LayerTransactionParent::LayerTransactionParent(HostLayerManager* aManager,
CompositorBridgeParentBase* aBridge,
uint64_t aId)
: mLayerManager(aManager)
@ -293,8 +293,8 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
case Edit::TOpCreatePaintedLayer: {
MOZ_LAYERS_LOG(("[ParentSide] CreatePaintedLayer"));
RefPtr<PaintedLayerComposite> layer =
layer_manager()->CreatePaintedLayerComposite();
RefPtr<PaintedLayer> layer =
layer_manager()->CreatePaintedLayer();
AsLayerComposite(edit.get_OpCreatePaintedLayer())->Bind(layer);
updateHitTestingTree = true;
@ -303,7 +303,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
case Edit::TOpCreateContainerLayer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateContainerLayer"));
RefPtr<ContainerLayer> layer = layer_manager()->CreateContainerLayerComposite();
RefPtr<ContainerLayer> layer = layer_manager()->CreateContainerLayer();
AsLayerComposite(edit.get_OpCreateContainerLayer())->Bind(layer);
updateHitTestingTree = true;
@ -312,8 +312,8 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
case Edit::TOpCreateImageLayer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateImageLayer"));
RefPtr<ImageLayerComposite> layer =
layer_manager()->CreateImageLayerComposite();
RefPtr<ImageLayer> layer =
layer_manager()->CreateImageLayer();
AsLayerComposite(edit.get_OpCreateImageLayer())->Bind(layer);
updateHitTestingTree = true;
@ -322,7 +322,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
case Edit::TOpCreateColorLayer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateColorLayer"));
RefPtr<ColorLayerComposite> layer = layer_manager()->CreateColorLayerComposite();
RefPtr<ColorLayer> layer = layer_manager()->CreateColorLayer();
AsLayerComposite(edit.get_OpCreateColorLayer())->Bind(layer);
updateHitTestingTree = true;
@ -331,8 +331,8 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
case Edit::TOpCreateCanvasLayer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateCanvasLayer"));
RefPtr<CanvasLayerComposite> layer =
layer_manager()->CreateCanvasLayerComposite();
RefPtr<CanvasLayer> layer =
layer_manager()->CreateCanvasLayer();
AsLayerComposite(edit.get_OpCreateCanvasLayer())->Bind(layer);
updateHitTestingTree = true;
@ -341,8 +341,8 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
case Edit::TOpCreateRefLayer: {
MOZ_LAYERS_LOG(("[ParentSide] CreateRefLayer"));
RefPtr<RefLayerComposite> layer =
layer_manager()->CreateRefLayerComposite();
RefPtr<RefLayer> layer =
layer_manager()->CreateRefLayer();
AsLayerComposite(edit.get_OpCreateRefLayer())->Bind(layer);
updateHitTestingTree = true;
@ -420,7 +420,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
case Specific::TPaintedLayerAttributes: {
MOZ_LAYERS_LOG(("[ParentSide] painted layer"));
PaintedLayerComposite* paintedLayer = layerParent->AsPaintedLayerComposite();
PaintedLayer* paintedLayer = layerParent->AsPaintedLayer();
if (!paintedLayer) {
return IPC_FAIL_NO_REASON(this);
}
@ -434,7 +434,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
case Specific::TContainerLayerAttributes: {
MOZ_LAYERS_LOG(("[ParentSide] container layer"));
ContainerLayerComposite* containerLayer = layerParent->AsContainerLayerComposite();
ContainerLayer* containerLayer = layerParent->AsContainerLayer();
if (!containerLayer) {
return IPC_FAIL_NO_REASON(this);
}
@ -451,7 +451,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
case Specific::TColorLayerAttributes: {
MOZ_LAYERS_LOG(("[ParentSide] color layer"));
ColorLayerComposite* colorLayer = layerParent->AsColorLayerComposite();
ColorLayer* colorLayer = layerParent->AsColorLayer();
if (!colorLayer) {
return IPC_FAIL_NO_REASON(this);
}
@ -462,7 +462,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
case Specific::TCanvasLayerAttributes: {
MOZ_LAYERS_LOG(("[ParentSide] canvas layer"));
CanvasLayerComposite* canvasLayer = layerParent->AsCanvasLayerComposite();
CanvasLayer* canvasLayer = layerParent->AsCanvasLayer();
if (!canvasLayer) {
return IPC_FAIL_NO_REASON(this);
}
@ -473,7 +473,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
case Specific::TRefLayerAttributes: {
MOZ_LAYERS_LOG(("[ParentSide] ref layer"));
RefLayerComposite* refLayer = layerParent->AsRefLayerComposite();
RefLayer* refLayer = layerParent->AsRefLayer();
if (!refLayer) {
return IPC_FAIL_NO_REASON(this);
}
@ -484,7 +484,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
case Specific::TImageLayerAttributes: {
MOZ_LAYERS_LOG(("[ParentSide] image layer"));
ImageLayerComposite* imageLayer = layerParent->AsImageLayerComposite();
ImageLayer* imageLayer = layerParent->AsImageLayer();
if (!imageLayer) {
return IPC_FAIL_NO_REASON(this);
}
@ -534,7 +534,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
if (!child) {
return IPC_FAIL_NO_REASON(this);
}
ContainerLayerComposite* container = ShadowContainer(oia)->AsContainerLayerComposite();
ContainerLayer* container = ShadowContainer(oia)->AsContainerLayer();
if (!container ||
!container->InsertAfter(child, ShadowAfter(oia)->AsLayer()))
{
@ -552,7 +552,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
if (!child) {
return IPC_FAIL_NO_REASON(this);
}
ContainerLayerComposite* container = ShadowContainer(oac)->AsContainerLayerComposite();
ContainerLayer* container = ShadowContainer(oac)->AsContainerLayer();
if (!container ||
!container->InsertAfter(child, nullptr))
{
@ -570,7 +570,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
if (!childLayer) {
return IPC_FAIL_NO_REASON(this);
}
ContainerLayerComposite* container = ShadowContainer(orc)->AsContainerLayerComposite();
ContainerLayer* container = ShadowContainer(orc)->AsContainerLayer();
if (!container ||
!container->RemoveChild(childLayer))
{
@ -588,7 +588,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
if (!child) {
return IPC_FAIL_NO_REASON(this);
}
ContainerLayerComposite* container = ShadowContainer(orc)->AsContainerLayerComposite();
ContainerLayer* container = ShadowContainer(orc)->AsContainerLayer();
if (!container ||
!container->RepositionChild(child, ShadowAfter(orc)->AsLayer()))
{
@ -606,7 +606,7 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
if (!child) {
return IPC_FAIL_NO_REASON(this);
}
ContainerLayerComposite* container = ShadowContainer(rtc)->AsContainerLayerComposite();
ContainerLayer* container = ShadowContainer(rtc)->AsContainerLayer();
if (!container ||
!container->RepositionChild(child, nullptr))
{
@ -634,7 +634,9 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
if (!Attach(cast(op.layerParent()), host, false)) {
return IPC_FAIL_NO_REASON(this);
}
host->SetCompositorID(mLayerManager->GetCompositor()->GetCompositorID());
if (mLayerManager->GetCompositor()) {
host->SetCompositorID(mLayerManager->GetCompositor()->GetCompositorID());
}
break;
}
case Edit::TOpAttachAsyncCompositable: {
@ -653,7 +655,9 @@ LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
if (!Attach(cast(op.layerParent()), host, true)) {
return IPC_FAIL_NO_REASON(this);
}
host->SetCompositorID(mLayerManager->GetCompositor()->GetCompositorID());
if (mLayerManager->GetCompositor()) {
host->SetCompositorID(mLayerManager->GetCompositor()->GetCompositorID());
}
break;
}
default:
@ -766,7 +770,7 @@ LayerTransactionParent::RecvGetAnimationOpacity(PLayerParent* aParent,
mCompositorBridge->ApplyAsyncProperties(this);
if (!layer->AsLayerComposite()->GetShadowOpacitySetByAnimation()) {
if (!layer->AsHostLayer()->GetShadowOpacitySetByAnimation()) {
return IPC_OK();
}
@ -800,7 +804,7 @@ LayerTransactionParent::RecvGetAnimationTransform(PLayerParent* aParent,
// recover the untranslated transform from the shadow transform. For
// transforms that are not set by animation we don't have this information
// available.
if (!layer->AsLayerComposite()->GetShadowTransformSetByAnimation()) {
if (!layer->AsHostLayer()->GetShadowTransformSetByAnimation()) {
*aTransform = mozilla::void_t();
return IPC_OK();
}
@ -809,7 +813,7 @@ LayerTransactionParent::RecvGetAnimationTransform(PLayerParent* aParent,
// from the shadow transform by undoing the translations in
// AsyncCompositionManager::SampleValue.
Matrix4x4 transform = layer->AsLayerComposite()->GetShadowBaseTransform();
Matrix4x4 transform = layer->AsHostLayer()->GetShadowBaseTransform();
if (ContainerLayer* c = layer->AsContainerLayer()) {
// Undo the scale transform applied by AsyncCompositionManager::SampleValue
transform.PostScale(1.0f/c->GetInheritedXScale(),
@ -953,13 +957,13 @@ LayerTransactionParent::Attach(ShadowLayerParent* aLayerParent,
if (!baselayer) {
return false;
}
LayerComposite* layer = baselayer->AsLayerComposite();
HostLayer* layer = baselayer->AsHostLayer();
if (!layer) {
return false;
}
Compositor* compositor
= static_cast<LayerManagerComposite*>(aLayerParent->AsLayer()->Manager())->GetCompositor();
= static_cast<HostLayerManager*>(aLayerParent->AsLayer()->Manager())->GetCompositor();
if (!layer->SetCompositableHost(aCompositable)) {
// not all layer types accept a compositable, see bug 967824

8
gfx/layers/ipc/LayerTransactionParent.h
Просмотреть файл

@ -29,7 +29,7 @@ class RenderFrameParent;
namespace layers {
class Layer;
class LayerManagerComposite;
class HostLayerManager;
class ShadowLayerParent;
class CompositableParent;
class CompositorBridgeParentBase;
@ -45,7 +45,7 @@ class LayerTransactionParent final : public PLayerTransactionParent,
typedef InfallibleTArray<PluginWindowData> PluginsArray;
public:
LayerTransactionParent(LayerManagerComposite* aManager,
LayerTransactionParent(HostLayerManager* aManager,
CompositorBridgeParentBase* aBridge,
uint64_t aId);
@ -55,7 +55,7 @@ protected:
public:
void Destroy();
LayerManagerComposite* layer_manager() const { return mLayerManager; }
HostLayerManager* layer_manager() const { return mLayerManager; }
uint64_t GetId() const { return mId; }
Layer* GetRoot() const { return mRoot; }
@ -189,7 +189,7 @@ protected:
friend class layout::RenderFrameParent;
private:
RefPtr<LayerManagerComposite> mLayerManager;
RefPtr<HostLayerManager> mLayerManager;
CompositorBridgeParentBase* mCompositorBridge;
// Hold the root because it might be grafted under various
// containers in the "real" layer tree

36
gfx/layers/ipc/ShadowLayerParent.cpp
Просмотреть файл

@ -56,51 +56,51 @@ ShadowLayerParent::Destroy()
Disconnect();
}
ContainerLayerComposite*
ShadowLayerParent::AsContainerLayerComposite() const
ContainerLayer*
ShadowLayerParent::AsContainerLayer() const
{
return mLayer && mLayer->GetType() == Layer::TYPE_CONTAINER
? static_cast<ContainerLayerComposite*>(mLayer.get())
? static_cast<ContainerLayer*>(mLayer.get())
: nullptr;
}
CanvasLayerComposite*
ShadowLayerParent::AsCanvasLayerComposite() const
CanvasLayer*
ShadowLayerParent::AsCanvasLayer() const
{
return mLayer && mLayer->GetType() == Layer::TYPE_CANVAS
? static_cast<CanvasLayerComposite*>(mLayer.get())
? static_cast<CanvasLayer*>(mLayer.get())
: nullptr;
}
ColorLayerComposite*
ShadowLayerParent::AsColorLayerComposite() const
ColorLayer*
ShadowLayerParent::AsColorLayer() const
{
return mLayer && mLayer->GetType() == Layer::TYPE_COLOR
? static_cast<ColorLayerComposite*>(mLayer.get())
? static_cast<ColorLayer*>(mLayer.get())
: nullptr;
}
ImageLayerComposite*
ShadowLayerParent::AsImageLayerComposite() const
ImageLayer*
ShadowLayerParent::AsImageLayer() const
{
return mLayer && mLayer->GetType() == Layer::TYPE_IMAGE
? static_cast<ImageLayerComposite*>(mLayer.get())
? static_cast<ImageLayer*>(mLayer.get())
: nullptr;
}
RefLayerComposite*
ShadowLayerParent::AsRefLayerComposite() const
RefLayer*
ShadowLayerParent::AsRefLayer() const
{
return mLayer && mLayer->GetType() == Layer::TYPE_REF
? static_cast<RefLayerComposite*>(mLayer.get())
? static_cast<RefLayer*>(mLayer.get())
: nullptr;
}
PaintedLayerComposite*
ShadowLayerParent::AsPaintedLayerComposite() const
PaintedLayer*
ShadowLayerParent::AsPaintedLayer() const
{
return mLayer && mLayer->GetType() == Layer::TYPE_PAINTED
? static_cast<PaintedLayerComposite*>(mLayer.get())
? static_cast<PaintedLayer*>(mLayer.get())
: nullptr;
}

24
gfx/layers/ipc/ShadowLayerParent.h
Просмотреть файл

@ -18,12 +18,12 @@ namespace layers {
class ContainerLayer;
class Layer;
class CanvasLayerComposite;
class ColorLayerComposite;
class ContainerLayerComposite;
class ImageLayerComposite;
class RefLayerComposite;
class PaintedLayerComposite;
class CanvasLayer;
class ColorLayer;
class ContainerLayer;
class ImageLayer;
class RefLayer;
class PaintedLayer;
class ShadowLayerParent : public PLayerParent
{
@ -37,12 +37,12 @@ public:
Layer* AsLayer() const { return mLayer; }
ContainerLayerComposite* AsContainerLayerComposite() const;
CanvasLayerComposite* AsCanvasLayerComposite() const;
ColorLayerComposite* AsColorLayerComposite() const;
ImageLayerComposite* AsImageLayerComposite() const;
RefLayerComposite* AsRefLayerComposite() const;
PaintedLayerComposite* AsPaintedLayerComposite() const;
ContainerLayer* AsContainerLayer() const;
CanvasLayer* AsCanvasLayer() const;
ColorLayer* AsColorLayer() const;
ImageLayer* AsImageLayer() const;
RefLayer* AsRefLayer() const;
PaintedLayer* AsPaintedLayer() const;
private:
virtual void ActorDestroy(ActorDestroyReason why) override;

2
gfx/tests/gtest/TestLayers.cpp
Просмотреть файл

@ -238,7 +238,7 @@ already_AddRefed<Layer> CreateLayerTree(
if (rootLayer) {
rootLayer->ComputeEffectiveTransforms(Matrix4x4());
manager->SetRoot(rootLayer);
if (rootLayer->AsLayerComposite()) {
if (rootLayer->AsHostLayer()) {
// Only perform this for LayerManagerComposite
CompositorBridgeParent::SetShadowProperties(rootLayer);
}