diff options
Diffstat (limited to '')
| -rw-r--r-- | gfx/layers/basic/BasicPaintedLayer.cpp | 239 |
1 files changed, 239 insertions, 0 deletions
diff --git a/gfx/layers/basic/BasicPaintedLayer.cpp b/gfx/layers/basic/BasicPaintedLayer.cpp new file mode 100644 index 0000000000..c8c9750831 --- /dev/null +++ b/gfx/layers/basic/BasicPaintedLayer.cpp @@ -0,0 +1,239 @@ +/* -*- 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 "BasicPaintedLayer.h" +#include <stdint.h> // for uint32_t +#include "GeckoProfiler.h" // for AUTO_PROFILER_LABEL +#include "ReadbackLayer.h" // for ReadbackLayer, ReadbackSink +#include "ReadbackProcessor.h" // for ReadbackProcessor::Update, etc +#include "RenderTrace.h" // for RenderTraceInvalidateEnd, etc +#include "BasicLayersImpl.h" // for AutoMaskData, etc +#include "gfxContext.h" // for gfxContext, etc +#include "gfxRect.h" // for gfxRect +#include "gfxUtils.h" // for gfxUtils +#include "mozilla/gfx/2D.h" // for DrawTarget +#include "mozilla/gfx/BaseRect.h" // for BaseRect +#include "mozilla/gfx/Matrix.h" // for Matrix +#include "mozilla/gfx/Rect.h" // for Rect, IntRect +#include "mozilla/gfx/Types.h" // for Float, etc +#include "mozilla/layers/LayersTypes.h" +#include "nsCOMPtr.h" // for already_AddRefed +#include "nsISupportsImpl.h" // for gfxContext::Release, etc +#include "nsPoint.h" // for nsIntPoint +#include "nsRect.h" // for mozilla::gfx::IntRect +#include "nsTArray.h" // for nsTArray, nsTArray_Impl +#include "AutoMaskData.h" +#include "gfx2DGlue.h" + +namespace mozilla { +namespace layers { + +using namespace mozilla::gfx; + +static nsIntRegion IntersectWithClip(const nsIntRegion& aRegion, + gfxContext* aContext) { + gfxRect clip = aContext->GetClipExtents(); + nsIntRegion result; + result.And(aRegion, IntRect::RoundOut(clip.X(), clip.Y(), clip.Width(), + clip.Height())); + return result; +} + +void BasicPaintedLayer::PaintThebes( + gfxContext* aContext, Layer* aMaskLayer, + LayerManager::DrawPaintedLayerCallback aCallback, void* aCallbackData) { + AUTO_PROFILER_LABEL("BasicPaintedLayer::PaintThebes", GRAPHICS); + + NS_ASSERTION(BasicManager()->InDrawing(), "Can only draw in drawing phase"); + + float opacity = GetEffectiveOpacity(); + CompositionOp effectiveOperator = GetEffectiveOperator(this); + + if (!BasicManager()->IsRetained()) { + ClearValidRegion(); + mContentClient->Clear(); + + nsIntRegion toDraw = + IntersectWithClip(GetLocalVisibleRegion().ToUnknownRegion(), aContext); + + RenderTraceInvalidateStart(this, "FFFF00", toDraw.GetBounds()); + + if (!toDraw.IsEmpty() && !IsHidden()) { + if (!aCallback) { + BasicManager()->SetTransactionIncomplete(); + return; + } + + aContext->Save(); + + bool needsGroup = opacity != 1.0 || + effectiveOperator != CompositionOp::OP_OVER || + aMaskLayer; + RefPtr<gfxContext> context = nullptr; + BasicLayerManager::PushedGroup group; + bool availableGroup = false; + + if (needsGroup) { + availableGroup = + BasicManager()->PushGroupForLayer(aContext, this, toDraw, group); + if (availableGroup) { + context = group.mGroupTarget; + } + } else { + context = aContext; + } + if (context) { + DrawTarget* target = context->GetDrawTarget(); + bool oldAA = target->GetPermitSubpixelAA(); + SetAntialiasingFlags(this, target); + aCallback(this, context, toDraw, toDraw, DrawRegionClip::NONE, + nsIntRegion(), aCallbackData); + target->SetPermitSubpixelAA(oldAA); + } + if (needsGroup && availableGroup) { + BasicManager()->PopGroupForLayer(group); + } + + aContext->Restore(); + } + + RenderTraceInvalidateEnd(this, "FFFF00"); + return; + } + + if (BasicManager()->IsTransactionIncomplete()) return; + + gfxRect clipExtents; + clipExtents = aContext->GetClipExtents(); + + // Pull out the mask surface and transform here, because the mask + // is internal to basic layers + AutoMoz2DMaskData mask; + SourceSurface* maskSurface = nullptr; + Matrix maskTransform; + if (GetMaskData(aMaskLayer, aContext->GetDeviceOffset(), &mask)) { + maskSurface = mask.GetSurface(); + maskTransform = mask.GetTransform(); + } + + if (!IsHidden() && !clipExtents.IsEmpty()) { + mContentClient->DrawTo(this, aContext->GetDrawTarget(), opacity, + effectiveOperator, maskSurface, &maskTransform); + } +} + +void BasicPaintedLayer::Validate( + LayerManager::DrawPaintedLayerCallback aCallback, void* aCallbackData, + ReadbackProcessor* aReadback) { + if (!mContentClient) { + // This client will have a null Forwarder, which means it will not have + // a ContentHost on the other side. + mContentClient = new ContentClientBasic(mBackend); + } + + if (!BasicManager()->IsRetained()) { + return; + } + + nsTArray<ReadbackProcessor::Update> readbackUpdates; + if (aReadback && UsedForReadback()) { + aReadback->GetPaintedLayerUpdates(this, &readbackUpdates); + } + + uint32_t flags = 0; +#ifndef MOZ_WIDGET_ANDROID + if (BasicManager()->CompositorMightResample()) { + flags |= ContentClient::PAINT_WILL_RESAMPLE; + } + if (!(flags & ContentClient::PAINT_WILL_RESAMPLE)) { + if (MayResample()) { + flags |= ContentClient::PAINT_WILL_RESAMPLE; + } + } +#endif + if (mDrawAtomically) { + flags |= ContentClient::PAINT_NO_ROTATION; + } + PaintState state = mContentClient->BeginPaint(this, flags); + SubtractFromValidRegion(state.mRegionToInvalidate); + + DrawTarget* target = mContentClient->BorrowDrawTargetForPainting(state); + if (target && target->IsValid()) { + // The area that became invalid and is visible needs to be repainted + // (this could be the whole visible area if our buffer switched + // from RGB to RGBA, because we might need to repaint with + // subpixel AA) + state.mRegionToInvalidate.And(state.mRegionToInvalidate, + GetLocalVisibleRegion().ToUnknownRegion()); + SetAntialiasingFlags(this, target); + + RenderTraceInvalidateStart(this, "FFFF00", state.mRegionToDraw.GetBounds()); + + RefPtr<gfxContext> ctx = + gfxContext::CreatePreservingTransformOrNull(target); + MOZ_ASSERT(ctx); // already checked the target above + + PaintBuffer(ctx, state.mRegionToDraw, state.mRegionToDraw, + state.mRegionToInvalidate, state.mClip, aCallback, + aCallbackData); + MOZ_LAYERS_LOG_IF_SHADOWABLE(this, + ("Layer::Mutated(%p) PaintThebes", this)); + Mutated(); + ctx = nullptr; + mContentClient->ReturnDrawTarget(target); + target = nullptr; + + RenderTraceInvalidateEnd(this, "FFFF00"); + } else { + if (target) { + mContentClient->ReturnDrawTarget(target); + target = nullptr; + } + + // It's possible that state.mRegionToInvalidate is nonempty here, + // if we are shrinking the valid region to nothing. So use mRegionToDraw + // instead. + NS_WARNING_ASSERTION( + state.mRegionToDraw.IsEmpty(), + "No context when we have something to draw, resource exhaustion?"); + } + + for (uint32_t i = 0; i < readbackUpdates.Length(); ++i) { + ReadbackProcessor::Update& update = readbackUpdates[i]; + nsIntPoint offset = update.mLayer->GetBackgroundLayerOffset(); + RefPtr<DrawTarget> dt = update.mLayer->GetSink()->BeginUpdate( + update.mUpdateRect + offset, update.mSequenceCounter); + if (dt) { + NS_ASSERTION(GetEffectiveOpacity() == 1.0, + "Should only read back opaque layers"); + NS_ASSERTION(!GetMaskLayer(), + "Should only read back layers without masks"); + dt->SetTransform(dt->GetTransform().PreTranslate(offset.x, offset.y)); + mContentClient->DrawTo(this, dt, 1.0, CompositionOp::OP_OVER, nullptr, + nullptr); + update.mLayer->GetSink()->EndUpdate(update.mUpdateRect + offset); + } + } +} + +already_AddRefed<PaintedLayer> BasicLayerManager::CreatePaintedLayer() { + NS_ASSERTION(InConstruction(), "Only allowed in construction phase"); + + BackendType backend = gfxPlatform::GetPlatform()->GetDefaultContentBackend(); + + if (mDefaultTarget) { + backend = mDefaultTarget->GetDrawTarget()->GetBackendType(); + } else if (mType == BLM_WIDGET) { + backend = gfxPlatform::GetPlatform()->GetContentBackendFor( + LayersBackend::LAYERS_BASIC); + } + + RefPtr<PaintedLayer> layer = new BasicPaintedLayer(this, backend); + return layer.forget(); +} + +} // namespace layers +} // namespace mozilla |