void
ThebesLayerComposite::RenderLayer(const nsIntPoint& aOffset,
const nsIntRect& aClipRect)
{
if (!mBuffer || !mBuffer->IsAttached()) {
return;
}
MOZ_ASSERT(mBuffer->GetCompositor() == mCompositeManager->GetCompositor() &&
mBuffer->GetLayer() == this,
"buffer is corrupted");
gfx::Matrix4x4 transform;
ToMatrix4x4(GetEffectiveTransform(), transform);
gfx::Rect clipRect(aClipRect.x, aClipRect.y, aClipRect.width, aClipRect.height);
#ifdef MOZ_DUMP_PAINTING
if (gfxUtils::sDumpPainting) {
nsRefPtr<gfxImageSurface> surf = mBuffer->GetAsSurface();
WriteSnapshotToDumpFile(this, surf);
}
#endif
EffectChain effectChain;
LayerManagerComposite::AddMaskEffect(mMaskLayer, effectChain);
nsIntRegion visibleRegion = GetEffectiveVisibleRegion();
TiledLayerProperties tiledLayerProps;
if (mRequiresTiledProperties) {
// calculating these things can be a little expensive, so don't
// do them if we don't have to
tiledLayerProps.mVisibleRegion = visibleRegion;
tiledLayerProps.mDisplayPort = GetDisplayPort();
tiledLayerProps.mEffectiveResolution = GetEffectiveResolution();
tiledLayerProps.mCompositionBounds = GetCompositionBounds();
tiledLayerProps.mRetainTiles = !mIsFixedPosition;
tiledLayerProps.mValidRegion = mValidRegion;
}
mBuffer->SetPaintWillResample(MayResample());
mBuffer->Composite(effectChain,
GetEffectiveOpacity(),
transform,
gfx::Point(aOffset.x, aOffset.y),
gfx::FILTER_LINEAR,
clipRect,
&visibleRegion,
mRequiresTiledProperties ? &tiledLayerProps
: nullptr);
if (mRequiresTiledProperties) {
mValidRegion = tiledLayerProps.mValidRegion;
}
LayerManagerComposite::RemoveMaskEffect(mMaskLayer);
mCompositeManager->GetCompositor()->MakeCurrent();
}
void
ThebesLayerComposite::RenderLayer(const nsIntRect& aClipRect)
{
if (!mBuffer || !mBuffer->IsAttached()) {
return;
}
PROFILER_LABEL("ThebesLayerComposite", "RenderLayer",
js::ProfileEntry::Category::GRAPHICS);
MOZ_ASSERT(mBuffer->GetCompositor() == mCompositeManager->GetCompositor() &&
mBuffer->GetLayer() == this,
"buffer is corrupted");
gfx::Rect clipRect(aClipRect.x, aClipRect.y, aClipRect.width, aClipRect.height);
#ifdef MOZ_DUMP_PAINTING
if (gfxUtils::sDumpPainting) {
RefPtr<gfx::DataSourceSurface> surf = mBuffer->GetAsSurface();
if (surf) {
WriteSnapshotToDumpFile(this, surf);
}
}
#endif
EffectChain effectChain(this);
LayerManagerComposite::AutoAddMaskEffect autoMaskEffect(mMaskLayer, effectChain);
AddBlendModeEffect(effectChain);
const nsIntRegion& visibleRegion = GetEffectiveVisibleRegion();
TiledLayerProperties tiledLayerProps;
if (mRequiresTiledProperties) {
tiledLayerProps.mVisibleRegion = visibleRegion;
tiledLayerProps.mEffectiveResolution = GetEffectiveResolution();
tiledLayerProps.mValidRegion = mValidRegion;
}
mBuffer->SetPaintWillResample(MayResample());
mBuffer->Composite(effectChain,
GetEffectiveOpacity(),
GetEffectiveTransform(),
gfx::Filter::LINEAR,
clipRect,
&visibleRegion,
mRequiresTiledProperties ? &tiledLayerProps
: nullptr);
mBuffer->BumpFlashCounter();
if (mRequiresTiledProperties) {
mValidRegion = tiledLayerProps.mValidRegion;
}
mCompositeManager->GetCompositor()->MakeCurrent();
}
gfxRect
ThebesLayerComposite::GetDisplayPort()
{
// We use GetTransform instead of GetEffectiveTransform in this function
// as we want the transform of the shadowable layers and not that of the
// shadow layers, which may have been modified due to async scrolling/
// zooming.
gfx3DMatrix transform = GetTransform();
// Find out the area of the nearest display-port to invalidate retained
// tiles.
gfxRect displayPort;
gfxSize parentResolution = GetEffectiveResolution();
for (ContainerLayer* parent = GetParent(); parent; parent = parent->GetParent()) {
const FrameMetrics& metrics = parent->GetFrameMetrics();
if (displayPort.IsEmpty()) {
if (!metrics.mDisplayPort.IsEmpty()) {
// We use the bounds to cut down on complication/computation time.
// This will be incorrect when the transform involves rotation, but
// it'd be quite hard to retain invalid tiles correctly in this
// situation anyway.
displayPort = gfxRect(metrics.mDisplayPort.x,
metrics.mDisplayPort.y,
metrics.mDisplayPort.width,
metrics.mDisplayPort.height);
displayPort.ScaleRoundOut(parentResolution.width, parentResolution.height);
}
parentResolution.width /= metrics.mResolution.scale;
parentResolution.height /= metrics.mResolution.scale;
}
if (parent->UseIntermediateSurface()) {
transform.PreMultiply(parent->GetTransform());
}
}
// If no display port was found, use the widget size from the layer manager.
if (displayPort.IsEmpty()) {
LayerManagerComposite* manager = static_cast<LayerManagerComposite*>(Manager());
const nsIntSize& widgetSize = manager->GetWidgetSize();
displayPort.width = widgetSize.width;
displayPort.height = widgetSize.height;
}
// Transform the display port into layer space.
displayPort = transform.Inverse().TransformBounds(displayPort);
return displayPort;
}
