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

974 строки
36 KiB
C++
Исходник Ответственный История

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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/. */
#include <stdint.h> // for uint32_t
#include <stdlib.h> // for rand, RAND_MAX
#include <sys/types.h> // for int32_t
#include <stack> // for stack
#include "BasicContainerLayer.h" // for BasicContainerLayer
#include "BasicLayersImpl.h" // for ToData, BasicReadbackLayer, etc
#include "ImageContainer.h" // for ImageFactory
#include "Layers.h" // for Layer, ContainerLayer, etc
#include "ReadbackLayer.h" // for ReadbackLayer
#include "ReadbackProcessor.h" // for ReadbackProcessor
#include "RenderTrace.h" // for RenderTraceLayers, etc
#include "basic/BasicImplData.h" // for BasicImplData
#include "basic/BasicLayers.h" // for BasicLayerManager, etc
#include "gfxASurface.h" // for gfxASurface, etc
#include "gfxContext.h" // for gfxContext, etc
#include "gfxImageSurface.h" // for gfxImageSurface
#include "gfxMatrix.h" // for gfxMatrix
#include "gfxPlatform.h" // for gfxPlatform
#include "gfxPoint.h" // for IntSize, gfxPoint
#include "gfxRect.h" // for gfxRect
#include "gfxUtils.h" // for gfxUtils
#include "gfx2DGlue.h" // for thebes --> moz2d transition
#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc
#include "mozilla/ProfilerLabels.h"
#include "mozilla/StaticPrefs_nglayout.h"
#include "mozilla/WidgetUtils.h" // for ScreenRotation
#include "mozilla/gfx/2D.h" // for DrawTarget
#include "mozilla/gfx/BasePoint.h" // for BasePoint
#include "mozilla/gfx/BaseRect.h" // for BaseRect
#include "mozilla/gfx/Matrix.h" // for Matrix
#include "mozilla/gfx/PathHelpers.h"
#include "mozilla/gfx/Rect.h" // for IntRect, Rect
#include "mozilla/layers/BSPTree.h"
#include "mozilla/layers/LayersTypes.h" // for BufferMode::BUFFER_NONE, etc
#include "mozilla/mozalloc.h" // for operator new
#include "nsCOMPtr.h" // for already_AddRefed
#include "nsDebug.h" // for NS_ASSERTION, etc
#include "nsISupportsImpl.h" // for gfxContext::Release, etc
#include "nsLayoutUtils.h" // for nsLayoutUtils
#include "nsPoint.h" // for nsIntPoint
#include "nsRect.h" // for mozilla::gfx::IntRect
#include "nsRegion.h" // for nsIntRegion, etc
#include "nsTArray.h" // for AutoTArray
#include "TreeTraversal.h" // for ForEachNode
class nsIWidget;
namespace mozilla {
namespace layers {
using namespace mozilla::gfx;
/**
* Clips to the smallest device-pixel-aligned rectangle containing aRect
* in user space.
* Returns true if the clip is "perfect", i.e. we actually clipped exactly to
* aRect.
*/
static bool ClipToContain(gfxContext* aContext, const IntRect& aRect) {
gfxRect userRect(aRect.X(), aRect.Y(), aRect.Width(), aRect.Height());
gfxRect deviceRect = aContext->UserToDevice(userRect);
deviceRect.RoundOut();
Matrix currentMatrix = aContext->CurrentMatrix();
aContext->SetMatrix(Matrix());
aContext->NewPath();
aContext->Rectangle(deviceRect);
aContext->Clip();
aContext->SetMatrix(currentMatrix);
return aContext->DeviceToUser(deviceRect).IsEqualInterior(userRect);
}
bool BasicLayerManager::PushGroupForLayer(gfxContext* aContext, Layer* aLayer,
const nsIntRegion& aRegion,
PushedGroup& aGroupResult) {
aGroupResult.mVisibleRegion = aRegion;
aGroupResult.mFinalTarget = aContext;
aGroupResult.mOperator = GetEffectiveOperator(aLayer);
aGroupResult.mOpacity = aLayer->GetEffectiveOpacity();
// If we need to call PushGroup, we should clip to the smallest possible
// area first to minimize the size of the temporary surface.
bool didCompleteClip = ClipToContain(aContext, aRegion.GetBounds());
bool canPushGroup =
aGroupResult.mOperator == CompositionOp::OP_OVER ||
(aGroupResult.mOperator == CompositionOp::OP_SOURCE &&
(aLayer->CanUseOpaqueSurface() ||
aLayer->GetContentFlags() & Layer::CONTENT_COMPONENT_ALPHA));
if (!canPushGroup) {
aContext->Save();
// Restore() is called in PopGroupForLayer
// if group.mFinalTarget != group.mGroupTarget
gfxUtils::ClipToRegion(aGroupResult.mFinalTarget,
aGroupResult.mVisibleRegion);
// PushGroup/PopGroup do not support non operator over.
gfxRect rect = aContext->GetClipExtents(gfxContext::eDeviceSpace);
rect.RoundOut();
IntRect surfRect;
ToRect(rect).ToIntRect(&surfRect);
if (!surfRect.IsEmpty()) {
RefPtr<DrawTarget> dt;
if (aContext->GetDrawTarget()->CanCreateSimilarDrawTarget(
surfRect.Size(), SurfaceFormat::B8G8R8A8)) {
dt = aContext->GetDrawTarget()->CreateSimilarDrawTarget(
surfRect.Size(), SurfaceFormat::B8G8R8A8);
}
RefPtr<gfxContext> ctx =
gfxContext::CreateOrNull(dt, ToRect(rect).TopLeft());
if (!ctx) {
gfxCriticalNote
<< "BasicLayerManager context problem in PushGroupForLayer "
<< gfx::hexa(dt);
aContext->Restore();
return false;
}
ctx->SetMatrix(aContext->CurrentMatrix());
aGroupResult.mGroupOffset = surfRect.TopLeft();
aGroupResult.mGroupTarget = ctx;
aGroupResult.mMaskSurface =
GetMaskForLayer(aLayer, &aGroupResult.mMaskTransform);
return true;
}
aContext->Restore();
}
Matrix maskTransform;
RefPtr<SourceSurface> maskSurf = GetMaskForLayer(aLayer, &maskTransform);
if (maskSurf) {
// The returned transform will transform the mask to device space on the
// destination. Since the User->Device space transform will be applied
// to the mask by PopGroupAndBlend we need to adjust the transform to
// transform the mask to user space.
Matrix currentTransform = aGroupResult.mFinalTarget->CurrentMatrix();
currentTransform.Invert();
maskTransform = maskTransform * currentTransform;
}
if (aLayer->CanUseOpaqueSurface() &&
((didCompleteClip && aRegion.GetNumRects() == 1) ||
!aContext->CurrentMatrix().HasNonIntegerTranslation())) {
// If the layer is opaque in its visible region we can push a
// gfxContentType::COLOR group. We need to make sure that only pixels inside
// the layer's visible region are copied back to the destination. Remember
// if we've already clipped precisely to the visible region.
aGroupResult.mNeedsClipToVisibleRegion =
!didCompleteClip || aRegion.GetNumRects() > 1;
if (aGroupResult.mNeedsClipToVisibleRegion) {
aGroupResult.mFinalTarget->Save();
gfxUtils::ClipToRegion(aGroupResult.mFinalTarget,
aGroupResult.mVisibleRegion);
}
aContext->PushGroupForBlendBack(
gfxContentType::COLOR, aGroupResult.mOpacity, maskSurf, maskTransform);
} else {
if (aLayer->GetContentFlags() & Layer::CONTENT_COMPONENT_ALPHA) {
aContext->PushGroupAndCopyBackground(gfxContentType::COLOR_ALPHA,
aGroupResult.mOpacity, maskSurf,
maskTransform);
} else {
aContext->PushGroupForBlendBack(gfxContentType::COLOR_ALPHA,
aGroupResult.mOpacity, maskSurf,
maskTransform);
}
}
aGroupResult.mGroupTarget = aGroupResult.mFinalTarget;
return true;
}
void BasicLayerManager::PopGroupForLayer(PushedGroup& group) {
if (group.mFinalTarget == group.mGroupTarget) {
group.mFinalTarget->PopGroupAndBlend();
if (group.mNeedsClipToVisibleRegion) {
group.mFinalTarget->Restore();
}
return;
}
DrawTarget* dt = group.mFinalTarget->GetDrawTarget();
RefPtr<DrawTarget> sourceDT = group.mGroupTarget->GetDrawTarget();
group.mGroupTarget = nullptr;
RefPtr<SourceSurface> src = sourceDT->Snapshot();
if (group.mMaskSurface) {
Point finalOffset = group.mFinalTarget->GetDeviceOffset();
dt->SetTransform(group.mMaskTransform * Matrix::Translation(-finalOffset));
Matrix surfTransform = group.mMaskTransform;
surfTransform.Invert();
dt->MaskSurface(SurfacePattern(src, ExtendMode::CLAMP,
surfTransform * Matrix::Translation(
group.mGroupOffset.x,
group.mGroupOffset.y)),
group.mMaskSurface, Point(0, 0),
DrawOptions(group.mOpacity, group.mOperator));
} else {
// For now this is required since our group offset is in device space of the
// final target, context but that may still have its own device offset. Once
// PushGroup/PopGroup logic is migrated to DrawTargets this can go as
// gfxContext::GetDeviceOffset will essentially always become null.
dt->SetTransform(
Matrix::Translation(-group.mFinalTarget->GetDeviceOffset()));
dt->DrawSurface(src,
Rect(group.mGroupOffset.x, group.mGroupOffset.y,
src->GetSize().width, src->GetSize().height),
Rect(0, 0, src->GetSize().width, src->GetSize().height),
DrawSurfaceOptions(SamplingFilter::POINT),
DrawOptions(group.mOpacity, group.mOperator));
}
if (group.mNeedsClipToVisibleRegion) {
dt->PopClip();
}
group.mFinalTarget->Restore();
}
static IntRect ToInsideIntRect(const gfxRect& aRect) {
return IntRect::RoundIn(aRect.X(), aRect.Y(), aRect.Width(), aRect.Height());
}
// A context helper for BasicLayerManager::PaintLayer() that holds all the
// painting context together in a data structure so it can be easily passed
// around. It also uses ensures that the Transform and Opaque rect are restored
// to their former state on destruction.
class PaintLayerContext {
public:
PaintLayerContext(gfxContext* aTarget, Layer* aLayer,
LayerManager::DrawPaintedLayerCallback aCallback,
void* aCallbackData)
: mTarget(aTarget),
mTargetMatrixSR(aTarget),
mLayer(aLayer),
mCallback(aCallback),
mCallbackData(aCallbackData),
mPushedOpaqueRect(false) {}
~PaintLayerContext() {
// Matrix is restored by mTargetMatrixSR
if (mPushedOpaqueRect) {
ClearOpaqueRect();
}
}
// Gets the effective transform and returns true if it is a 2D
// transform.
bool Setup2DTransform() {
// Will return an identity matrix for 3d transforms.
return mLayer->GetEffectiveTransformForBuffer().CanDraw2D(&mTransform);
}
// Applies the effective transform if it's 2D. If it's a 3D transform then
// it applies an identity.
void Apply2DTransform() { mTarget->SetMatrix(mTransform); }
// Set the opaque rect to match the bounds of the visible region.
void AnnotateOpaqueRect() {
const nsIntRegion visibleRegion =
mLayer->GetLocalVisibleRegion().ToUnknownRegion();
const IntRect& bounds = visibleRegion.GetBounds();
DrawTarget* dt = mTarget->GetDrawTarget();
const IntRect& targetOpaqueRect = dt->GetOpaqueRect();
// Try to annotate currentSurface with a region of pixels that have been
// (or will be) painted opaque, if no such region is currently set.
if (targetOpaqueRect.IsEmpty() && visibleRegion.GetNumRects() == 1 &&
(mLayer->GetContentFlags() & Layer::CONTENT_OPAQUE) &&
!mTransform.HasNonAxisAlignedTransform()) {
gfx::Rect opaqueRect = dt->GetTransform().TransformBounds(
gfx::Rect(bounds.X(), bounds.Y(), bounds.Width(), bounds.Height()));
opaqueRect.RoundIn();
IntRect intOpaqueRect;
if (opaqueRect.ToIntRect(&intOpaqueRect)) {
mTarget->GetDrawTarget()->SetOpaqueRect(intOpaqueRect);
mPushedOpaqueRect = true;
}
}
}
// Clear the Opaque rect. Although this doesn't really restore it to it's
// previous state it will happen on the exit path of the PaintLayer() so when
// painting is complete the opaque rect qill be clear.
void ClearOpaqueRect() { mTarget->GetDrawTarget()->SetOpaqueRect(IntRect()); }
gfxContext* mTarget;
gfxContextMatrixAutoSaveRestore mTargetMatrixSR;
Layer* mLayer;
LayerManager::DrawPaintedLayerCallback mCallback;
void* mCallbackData;
Matrix mTransform;
bool mPushedOpaqueRect;
};
BasicLayerManager::BasicLayerManager(nsIWidget* aWidget)
: mPhase(PHASE_NONE),
mWidget(aWidget),
mDoubleBuffering(BufferMode::BUFFER_NONE),
mType(BLM_WIDGET),
mUsingDefaultTarget(false),
mTransactionIncomplete(false),
mCompositorMightResample(false) {
MOZ_COUNT_CTOR(BasicLayerManager);
NS_ASSERTION(aWidget, "Must provide a widget");
}
BasicLayerManager::BasicLayerManager(BasicLayerManagerType aType)
: mPhase(PHASE_NONE),
mWidget(nullptr),
mDoubleBuffering(BufferMode::BUFFER_NONE),
mType(aType),
mUsingDefaultTarget(false),
mTransactionIncomplete(false),
mCompositorMightResample(false) {
MOZ_COUNT_CTOR(BasicLayerManager);
MOZ_ASSERT(mType != BLM_WIDGET);
}
BasicLayerManager::~BasicLayerManager() {
NS_ASSERTION(!InTransaction(), "Died during transaction?");
ClearCachedResources();
mRoot = nullptr;
MOZ_COUNT_DTOR(BasicLayerManager);
}
void BasicLayerManager::SetDefaultTarget(gfxContext* aContext) {
NS_ASSERTION(!InTransaction(), "Must set default target outside transaction");
mDefaultTarget = aContext;
}
void BasicLayerManager::SetDefaultTargetConfiguration(
BufferMode aDoubleBuffering, ScreenRotation aRotation) {
mDoubleBuffering = aDoubleBuffering;
}
bool BasicLayerManager::BeginTransaction(const nsCString& aURL) {
mInTransaction = true;
mUsingDefaultTarget = true;
return BeginTransactionWithTarget(mDefaultTarget, aURL);
}
bool BasicLayerManager::BeginTransactionWithTarget(gfxContext* aTarget,
const nsCString& aURL) {
mInTransaction = true;
#ifdef MOZ_LAYERS_HAVE_LOG
MOZ_LAYERS_LOG(("[----- BeginTransaction"));
Log();
#endif
NS_ASSERTION(!InTransaction(), "Nested transactions not allowed");
mPhase = PHASE_CONSTRUCTION;
mTarget = aTarget;
return true;
}
static void TransformIntRect(IntRect& aRect, const Matrix& aMatrix,
IntRect (*aRoundMethod)(const gfxRect&)) {
Rect gr = Rect(aRect.X(), aRect.Y(), aRect.Width(), aRect.Height());
gr = aMatrix.TransformBounds(gr);
aRect = (*aRoundMethod)(ThebesRect(gr));
}
/**
* This function assumes that GetEffectiveTransform transforms
* all layers to the same coordinate system (the "root coordinate system").
* It can't be used as is by accelerated layers because of intermediate
* surfaces. This must set the hidden flag to true or false on *all* layers in
* the subtree. It also sets the operator for all layers to "OVER", and call
* SetDrawAtomically(false).
* It clears mClipToVisibleRegion on all layers.
* @param aClipRect the cliprect, in the root coordinate system. We assume
* that any layer drawing is clipped to this rect. It is therefore not
* allowed to add to the opaque region outside that rect.
* @param aDirtyRect the dirty rect that will be painted, in the root
* coordinate system. Layers outside this rect should be hidden.
* @param aOpaqueRegion the opaque region covering aLayer, in the
* root coordinate system.
*/
enum {
ALLOW_OPAQUE = 0x01,
};
static void MarkLayersHidden(Layer* aLayer, const IntRect& aClipRect,
const IntRect& aDirtyRect,
nsIntRegion& aOpaqueRegion, uint32_t aFlags) {
IntRect newClipRect(aClipRect);
uint32_t newFlags = aFlags;
// Allow aLayer or aLayer's descendants to cover underlying layers
// only if it's opaque.
if (aLayer->GetOpacity() != 1.0f) {
newFlags &= ~ALLOW_OPAQUE;
}
{
const Maybe<ParentLayerIntRect>& clipRect = aLayer->GetLocalClipRect();
if (clipRect) {
IntRect cr = clipRect->ToUnknownRect();
// clipRect is in the container's coordinate system. Get it into the
// global coordinate system.
if (aLayer->GetParent()) {
Matrix tr;
if (aLayer->GetParent()->GetEffectiveTransform().CanDraw2D(&tr)) {
// Clip rect is applied after aLayer's transform, i.e., in the
// coordinate system of aLayer's parent.
TransformIntRect(cr, tr, ToInsideIntRect);
} else {
cr.SetRect(0, 0, 0, 0);
}
}
newClipRect.IntersectRect(newClipRect, cr);
}
}
BasicImplData* data = ToData(aLayer);
data->SetOperator(CompositionOp::OP_OVER);
data->SetClipToVisibleRegion(false);
data->SetDrawAtomically(false);
if (!aLayer->AsContainerLayer()) {
Matrix transform;
if (!aLayer->GetEffectiveTransform().CanDraw2D(&transform)) {
data->SetHidden(false);
return;
}
nsIntRegion region = aLayer->GetLocalVisibleRegion().ToUnknownRegion();
IntRect r = region.GetBounds();
TransformIntRect(r, transform, ToOutsideIntRect);
r.IntersectRect(r, aDirtyRect);
data->SetHidden(aOpaqueRegion.Contains(r));
// Allow aLayer to cover underlying layers only if aLayer's
// content is opaque
if ((aLayer->GetContentFlags() & Layer::CONTENT_OPAQUE) &&
(newFlags & ALLOW_OPAQUE)) {
for (auto iter = region.RectIter(); !iter.Done(); iter.Next()) {
r = iter.Get();
TransformIntRect(r, transform, ToInsideIntRect);
r.IntersectRect(r, newClipRect);
aOpaqueRegion.Or(aOpaqueRegion, r);
}
}
} else {
Layer* child = aLayer->GetLastChild();
bool allHidden = true;
for (; child; child = child->GetPrevSibling()) {
MarkLayersHidden(child, newClipRect, aDirtyRect, aOpaqueRegion, newFlags);
if (!ToData(child)->IsHidden()) {
allHidden = false;
}
}
data->SetHidden(allHidden);
}
}
/**
* This function assumes that GetEffectiveTransform transforms
* all layers to the same coordinate system (the "root coordinate system").
* MarkLayersHidden must be called before calling this.
* @param aVisibleRect the rectangle of aLayer that is visible (i.e. not
* clipped and in the dirty rect), in the root coordinate system.
*/
static void ApplyDoubleBuffering(Layer* aLayer, const IntRect& aVisibleRect) {
BasicImplData* data = ToData(aLayer);
if (data->IsHidden()) return;
IntRect newVisibleRect(aVisibleRect);
{
const Maybe<ParentLayerIntRect>& clipRect = aLayer->GetLocalClipRect();
if (clipRect) {
IntRect cr = clipRect->ToUnknownRect();
// clipRect is in the container's coordinate system. Get it into the
// global coordinate system.
if (aLayer->GetParent()) {
Matrix tr;
if (aLayer->GetParent()->GetEffectiveTransform().CanDraw2D(&tr)) {
NS_ASSERTION(!ThebesMatrix(tr).HasNonIntegerTranslation(),
"Parent can only have an integer translation");
cr += nsIntPoint(int32_t(tr._31), int32_t(tr._32));
} else {
NS_ERROR("Parent can only have an integer translation");
}
}
newVisibleRect.IntersectRect(newVisibleRect, cr);
}
}
BasicContainerLayer* container =
static_cast<BasicContainerLayer*>(aLayer->AsContainerLayer());
// Layers that act as their own backbuffers should be drawn to the destination
// using OP_SOURCE to ensure that alpha values in a transparent window are
// cleared. This can also be faster than OP_OVER.
if (!container) {
data->SetOperator(CompositionOp::OP_SOURCE);
data->SetDrawAtomically(true);
} else {
if (container->UseIntermediateSurface() ||
!container->ChildrenPartitionVisibleRegion(newVisibleRect)) {
// We need to double-buffer this container.
data->SetOperator(CompositionOp::OP_SOURCE);
container->ForceIntermediateSurface();
} else {
// Tell the children to clip to their visible regions so our assumption
// that they don't paint outside their visible regions is valid!
for (Layer* child = aLayer->GetFirstChild(); child;
child = child->GetNextSibling()) {
ToData(child)->SetClipToVisibleRegion(true);
ApplyDoubleBuffering(child, newVisibleRect);
}
}
}
}
void BasicLayerManager::EndTransaction(DrawPaintedLayerCallback aCallback,
void* aCallbackData,
EndTransactionFlags aFlags) {
mInTransaction = false;
EndTransactionInternal(aCallback, aCallbackData, aFlags);
}
void BasicLayerManager::AbortTransaction() {
NS_ASSERTION(InConstruction(), "Should be in construction phase");
mPhase = PHASE_NONE;
mUsingDefaultTarget = false;
mInTransaction = false;
}
bool BasicLayerManager::EndTransactionInternal(
DrawPaintedLayerCallback aCallback, void* aCallbackData,
EndTransactionFlags aFlags) {
AUTO_PROFILER_LABEL("BasicLayerManager::EndTransactionInternal", GRAPHICS);
#ifdef MOZ_LAYERS_HAVE_LOG
MOZ_LAYERS_LOG((" ----- (beginning paint)"));
Log();
#endif
NS_ASSERTION(InConstruction(), "Should be in construction phase");
mPhase = PHASE_DRAWING;
SetCompositionTime(TimeStamp::Now());
RenderTraceLayers(mRoot, "FF00");
mTransactionIncomplete = false;
std::unordered_set<ScrollableLayerGuid::ViewID> scrollIdsUpdated;
if (mRoot) {
if (aFlags & END_NO_COMPOSITE) {
// Apply pending tree updates before recomputing effective
// properties.
scrollIdsUpdated = mRoot->ApplyPendingUpdatesToSubtree();
}
// Need to do this before we call ApplyDoubleBuffering,
// which depends on correct effective transforms
if (mTarget) {
mSnapEffectiveTransforms =
!mTarget->GetDrawTarget()->GetUserData(&sDisablePixelSnapping);
} else {
mSnapEffectiveTransforms = true;
}
mRoot->ComputeEffectiveTransforms(
mTarget ? Matrix4x4::From2D(mTarget->CurrentMatrix()) : Matrix4x4());
ToData(mRoot)->Validate(aCallback, aCallbackData, nullptr);
if (mRoot->GetMaskLayer()) {
ToData(mRoot->GetMaskLayer())
->Validate(aCallback, aCallbackData, nullptr);
}
}
if (mTarget && mRoot && !(aFlags & END_NO_IMMEDIATE_REDRAW) &&
!(aFlags & END_NO_COMPOSITE)) {
IntRect clipRect =
ToOutsideIntRect(mTarget->GetClipExtents(gfxContext::eDeviceSpace));
if (IsRetained()) {
nsIntRegion region;
MarkLayersHidden(mRoot, clipRect, clipRect, region, ALLOW_OPAQUE);
if (mUsingDefaultTarget && mDoubleBuffering != BufferMode::BUFFER_NONE) {
ApplyDoubleBuffering(mRoot, clipRect);
}
}
PaintLayer(mTarget, mRoot, aCallback, aCallbackData);
if (!mRegionToClear.IsEmpty()) {
for (auto iter = mRegionToClear.RectIter(); !iter.Done(); iter.Next()) {
const IntRect& r = iter.Get();
mTarget->GetDrawTarget()->ClearRect(
Rect(r.X(), r.Y(), r.Width(), r.Height()));
}
}
if (mWidget) {
FlashWidgetUpdateArea(mTarget);
}
RecordFrame();
if (!mTransactionIncomplete) {
// Clear out target if we have a complete transaction.
mTarget = nullptr;
}
}
if (mRoot) {
mAnimationReadyTime = TimeStamp::Now();
mRoot->StartPendingAnimations(mAnimationReadyTime);
// Once we're sure we're not going to fall back to a full paint,
// notify the scroll frames which had pending updates.
if (!mTransactionIncomplete) {
for (ScrollableLayerGuid::ViewID scrollId : scrollIdsUpdated) {
nsLayoutUtils::NotifyPaintSkipTransaction(scrollId);
}
}
}
#ifdef MOZ_LAYERS_HAVE_LOG
Log();
MOZ_LAYERS_LOG(("]----- EndTransaction"));
#endif
// Go back to the construction phase if the transaction isn't complete.
// Layout will update the layer tree and call EndTransaction().
mPhase = mTransactionIncomplete ? PHASE_CONSTRUCTION : PHASE_NONE;
if (!mTransactionIncomplete) {
// This is still valid if the transaction was incomplete.
mUsingDefaultTarget = false;
}
NS_ASSERTION(!aCallback || !mTransactionIncomplete,
"If callback is not null, transaction must be complete");
// XXX - We should probably assert here that for an incomplete transaction
// out target is the default target.
return !mTransactionIncomplete;
}
void BasicLayerManager::FlashWidgetUpdateArea(gfxContext* aContext) {
if (StaticPrefs::nglayout_debug_widget_update_flashing()) {
float r = float(rand()) / float(RAND_MAX);
float g = float(rand()) / float(RAND_MAX);
float b = float(rand()) / float(RAND_MAX);
aContext->SetDeviceColor(DeviceColor(r, g, b, 0.2f));
aContext->Paint();
}
}
bool BasicLayerManager::EndEmptyTransaction(EndTransactionFlags aFlags) {
mInTransaction = false;
if (!mRoot) {
return false;
}
return EndTransactionInternal(nullptr, nullptr, aFlags);
}
void BasicLayerManager::SetRoot(Layer* aLayer) {
NS_ASSERTION(aLayer, "Root can't be null");
NS_ASSERTION(aLayer->Manager() == this, "Wrong manager");
NS_ASSERTION(InConstruction(), "Only allowed in construction phase");
mRoot = aLayer;
}
void BasicLayerManager::PaintSelfOrChildren(PaintLayerContext& aPaintContext,
gfxContext* aGroupTarget) {
MOZ_ASSERT(aGroupTarget);
BasicImplData* data = ToData(aPaintContext.mLayer);
/* Only paint ourself, or our children - This optimization relies on this! */
Layer* child = aPaintContext.mLayer->GetFirstChild();
if (!child) {
if (aPaintContext.mLayer->AsPaintedLayer()) {
data->PaintThebes(aGroupTarget, aPaintContext.mLayer->GetMaskLayer(),
aPaintContext.mCallback, aPaintContext.mCallbackData);
} else {
data->Paint(aGroupTarget->GetDrawTarget(),
aGroupTarget->GetDeviceOffset(),
aPaintContext.mLayer->GetMaskLayer());
}
} else {
ContainerLayer* container =
static_cast<ContainerLayer*>(aPaintContext.mLayer);
nsTArray<LayerPolygon> children = container->SortChildrenBy3DZOrder(
ContainerLayer::SortMode::WITHOUT_GEOMETRY);
for (uint32_t i = 0; i < children.Length(); i++) {
Layer* layer = children.ElementAt(i).layer;
if (layer->IsBackfaceHidden()) {
continue;
}
if (!layer->AsContainerLayer() && !layer->IsVisible()) {
continue;
}
PaintLayer(aGroupTarget, layer, aPaintContext.mCallback,
aPaintContext.mCallbackData);
if (mTransactionIncomplete) break;
}
}
}
void BasicLayerManager::FlushGroup(PaintLayerContext& aPaintContext,
bool aNeedsClipToVisibleRegion) {
// If we're doing our own double-buffering, we need to avoid drawing
// the results of an incomplete transaction to the destination surface ---
// that could cause flicker. Double-buffering is implemented using a
// temporary surface for one or more container layers, so we need to stop
// those temporary surfaces from being composited to aTarget.
// ApplyDoubleBuffering guarantees that this container layer can't
// intersect any other leaf layers, so if the transaction is not yet marked
// incomplete, the contents of this container layer are the final contents
// for the window.
if (!mTransactionIncomplete) {
if (aNeedsClipToVisibleRegion) {
gfxUtils::ClipToRegion(
aPaintContext.mTarget,
aPaintContext.mLayer->GetLocalVisibleRegion().ToUnknownRegion());
}
CompositionOp op = GetEffectiveOperator(aPaintContext.mLayer);
AutoSetOperator setOperator(aPaintContext.mTarget, op);
PaintWithMask(aPaintContext.mTarget,
aPaintContext.mLayer->GetEffectiveOpacity(),
aPaintContext.mLayer->GetMaskLayer());
}
}
/**
* Install the clip applied to the layer on the given gfxContext. The
* given gfxContext is the buffer that the layer will be painted to.
*/
static void InstallLayerClipPreserves3D(gfxContext* aTarget, Layer* aLayer) {
const Maybe<ParentLayerIntRect>& clipRect = aLayer->GetLocalClipRect();
if (!clipRect) {
return;
}
MOZ_ASSERT(
!aLayer->Extend3DContext() || !aLayer->Combines3DTransformWithAncestors(),
"Layers in a preserve 3D context have no clip"
" except leaves and the estabisher!");
Layer* parent = aLayer->GetParent();
Matrix4x4 transform3d = parent && parent->Extend3DContext()
? parent->GetEffectiveTransform()
: Matrix4x4();
Matrix transform;
if (!transform3d.CanDraw2D(&transform)) {
gfxDevCrash(LogReason::CannotDraw3D)
<< "GFX: We should not have a 3D transform that CanDraw2D() is false!";
}
Matrix oldTransform = aTarget->CurrentMatrix();
transform *= oldTransform;
aTarget->SetMatrix(transform);
aTarget->SnappedClip(gfxRect(clipRect->X(), clipRect->Y(), clipRect->Width(),
clipRect->Height()));
aTarget->SetMatrix(oldTransform);
}
void BasicLayerManager::PaintLayer(gfxContext* aTarget, Layer* aLayer,
DrawPaintedLayerCallback aCallback,
void* aCallbackData) {
MOZ_ASSERT(aTarget);
AUTO_PROFILER_LABEL("BasicLayerManager::PaintLayer", GRAPHICS);
PaintLayerContext paintLayerContext(aTarget, aLayer, aCallback,
aCallbackData);
// Don't attempt to paint layers with a singular transform, cairo will
// just throw an error.
if (aLayer->GetEffectiveTransform().IsSingular()) {
return;
}
RenderTraceScope trace("BasicLayerManager::PaintLayer", "707070");
const Maybe<ParentLayerIntRect>& clipRect = aLayer->GetLocalClipRect();
BasicContainerLayer* container =
static_cast<BasicContainerLayer*>(aLayer->AsContainerLayer());
bool needsGroup = container && container->UseIntermediateSurface();
BasicImplData* data = ToData(aLayer);
bool needsClipToVisibleRegion =
data->GetClipToVisibleRegion() && !aLayer->AsPaintedLayer();
NS_ASSERTION(needsGroup || !container ||
container->GetOperator() == CompositionOp::OP_OVER,
"non-OVER operator should have forced UseIntermediateSurface");
NS_ASSERTION(
!container || !aLayer->GetMaskLayer() ||
container->UseIntermediateSurface(),
"ContainerLayer with mask layer should force UseIntermediateSurface");
gfxContextAutoSaveRestore contextSR;
gfxMatrix transform;
// Will return an identity matrix for 3d transforms, and is handled separately
// below.
bool is2D = paintLayerContext.Setup2DTransform();
MOZ_ASSERT(is2D || needsGroup || !container || container->Extend3DContext() ||
container->Is3DContextLeaf(),
"Must PushGroup for 3d transforms!");
Layer* parent = aLayer->GetParent();
bool inPreserves3DChain = parent && parent->Extend3DContext();
bool needsSaveRestore = needsGroup || clipRect || needsClipToVisibleRegion ||
!is2D || inPreserves3DChain;
if (needsSaveRestore) {
contextSR.SetContext(aTarget);
// The clips on ancestors on the preserved3d chain should be
// installed on the aTarget before painting the layer.
InstallLayerClipPreserves3D(aTarget, aLayer);
for (Layer* l = parent; l && l->Extend3DContext(); l = l->GetParent()) {
InstallLayerClipPreserves3D(aTarget, l);
}
}
paintLayerContext.Apply2DTransform();
nsIntRegion visibleRegion = aLayer->GetLocalVisibleRegion().ToUnknownRegion();
// If needsGroup is true, we'll clip to the visible region after we've popped
// the group
if (needsClipToVisibleRegion && !needsGroup) {
gfxUtils::ClipToRegion(aTarget, visibleRegion);
// Don't need to clip to visible region again
needsClipToVisibleRegion = false;
}
if (is2D) {
paintLayerContext.AnnotateOpaqueRect();
}
bool clipIsEmpty = aTarget->GetClipExtents().IsEmpty();
if (clipIsEmpty) {
PaintSelfOrChildren(paintLayerContext, aTarget);
return;
}
if (is2D) {
if (needsGroup) {
PushedGroup pushedGroup;
if (PushGroupForLayer(aTarget, aLayer,
aLayer->GetLocalVisibleRegion().ToUnknownRegion(),
pushedGroup)) {
PaintSelfOrChildren(paintLayerContext, pushedGroup.mGroupTarget);
PopGroupForLayer(pushedGroup);
}
} else {
PaintSelfOrChildren(paintLayerContext, aTarget);
}
} else {
if (!needsGroup && container) {
PaintSelfOrChildren(paintLayerContext, aTarget);
return;
}
IntRect bounds = visibleRegion.GetBounds();
// DrawTarget without the 3D transform applied:
RefPtr<DrawTarget> untransformedDT =
gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(
IntSize(bounds.Width(), bounds.Height()), SurfaceFormat::B8G8R8A8);
if (!untransformedDT || !untransformedDT->IsValid()) {
return;
}
untransformedDT->SetTransform(
Matrix::Translation(-Point(bounds.X(), bounds.Y())));
RefPtr<gfxContext> groupTarget =
gfxContext::CreatePreservingTransformOrNull(untransformedDT);
MOZ_ASSERT(groupTarget); // already checked the target above
PaintSelfOrChildren(paintLayerContext, groupTarget);
// Temporary fast fix for bug 725886
// Revert these changes when 725886 is ready
#ifdef DEBUG
if (aLayer->GetDebugColorIndex() != 0) {
DeviceColor color((aLayer->GetDebugColorIndex() & 1) ? 1.f : 0.f,
(aLayer->GetDebugColorIndex() & 2) ? 1.f : 0.f,
(aLayer->GetDebugColorIndex() & 4) ? 1.f : 0.f);
untransformedDT->FillRect(Rect(bounds), ColorPattern(color));
}
#endif
Matrix4x4 effectiveTransform = aLayer->GetEffectiveTransform();
Rect xformBounds = effectiveTransform.TransformAndClipBounds(
Rect(bounds), ToRect(aTarget->GetClipExtents()));
xformBounds.RoundOut();
effectiveTransform.PostTranslate(-xformBounds.X(), -xformBounds.Y(), 0);
effectiveTransform.PreTranslate(bounds.X(), bounds.Y(), 0);
RefPtr<SourceSurface> untransformedSurf = untransformedDT->Snapshot();
RefPtr<DrawTarget> xformDT = untransformedDT->CreateSimilarDrawTarget(
IntSize::Truncate(xformBounds.Width(), xformBounds.Height()),
SurfaceFormat::B8G8R8A8);
RefPtr<SourceSurface> xformSurf;
if (xformDT && untransformedSurf &&
xformDT->Draw3DTransformedSurface(untransformedSurf,
effectiveTransform)) {
xformSurf = xformDT->Snapshot();
}
if (xformSurf) {
aTarget->SetPattern(new gfxPattern(
xformSurf, Matrix::Translation(xformBounds.TopLeft())));
// Azure doesn't support EXTEND_NONE, so to avoid extending the edges
// of the source surface out to the current clip region, clip to
// the rectangle of the result surface now.
aTarget->SnappedClip(ThebesRect(xformBounds));
FlushGroup(paintLayerContext, needsClipToVisibleRegion);
}
}
}
void BasicLayerManager::ClearCachedResources(Layer* aSubtree) {
MOZ_ASSERT(!aSubtree || aSubtree->Manager() == this);
if (aSubtree) {
ClearLayer(aSubtree);
} else if (mRoot) {
ClearLayer(mRoot);
}
}
void BasicLayerManager::ClearLayer(Layer* aLayer) {
ToData(aLayer)->ClearCachedResources();
for (Layer* child = aLayer->GetFirstChild(); child;
child = child->GetNextSibling()) {
ClearLayer(child);
}
}
already_AddRefed<ReadbackLayer> BasicLayerManager::CreateReadbackLayer() {
NS_ASSERTION(InConstruction(), "Only allowed in construction phase");
RefPtr<ReadbackLayer> layer = new BasicReadbackLayer(this);
return layer.forget();
}
} // namespace layers
} // namespace mozilla
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку