diff options
Diffstat (limited to 'layout/generic/nsHTMLCanvasFrame.cpp')
| -rw-r--r-- | layout/generic/nsHTMLCanvasFrame.cpp | 534 |
1 files changed, 534 insertions, 0 deletions
diff --git a/layout/generic/nsHTMLCanvasFrame.cpp b/layout/generic/nsHTMLCanvasFrame.cpp new file mode 100644 index 0000000000..2ccb6f0b20 --- /dev/null +++ b/layout/generic/nsHTMLCanvasFrame.cpp @@ -0,0 +1,534 @@ +/* -*- 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/. */ + +/* rendering object for the HTML <canvas> element */ + +#include "nsHTMLCanvasFrame.h" + +#include "nsGkAtoms.h" +#include "mozilla/Assertions.h" +#include "mozilla/PresShell.h" +#include "mozilla/dom/HTMLCanvasElement.h" +#include "mozilla/layers/ImageDataSerializer.h" +#include "mozilla/layers/WebRenderBridgeChild.h" +#include "mozilla/layers/WebRenderCanvasRenderer.h" +#include "mozilla/layers/RenderRootStateManager.h" +#include "mozilla/webgpu/CanvasContext.h" +#include "nsDisplayList.h" +#include "nsLayoutUtils.h" +#include "nsStyleUtil.h" +#include "ActiveLayerTracker.h" + +#include <algorithm> + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::layers; +using namespace mozilla::gfx; + +/* Helper for our nsIFrame::GetIntrinsicSize() impl. Takes the result of + * "GetCanvasSize()" as a parameter, which may help avoid redundant + * indirect calls to GetCanvasSize(). + * + * @param aCanvasSizeInPx The canvas's size in CSS pixels, as returned + * by GetCanvasSize(). + * @return The canvas's intrinsic size, as an IntrinsicSize object. + */ +static IntrinsicSize IntrinsicSizeFromCanvasSize( + const nsIntSize& aCanvasSizeInPx) { + return IntrinsicSize( + nsPresContext::CSSPixelsToAppUnits(aCanvasSizeInPx.width), + nsPresContext::CSSPixelsToAppUnits(aCanvasSizeInPx.height)); +} + +/* Helper for our nsIFrame::GetIntrinsicRatio() impl. Takes the result of + * "GetCanvasSize()" as a parameter, which may help avoid redundant + * indirect calls to GetCanvasSize(). + * + * @return The canvas's intrinsic ratio. + */ +static AspectRatio IntrinsicRatioFromCanvasSize( + const nsIntSize& aCanvasSizeInPx) { + return AspectRatio::FromSize(aCanvasSizeInPx.width, aCanvasSizeInPx.height); +} + +class nsDisplayCanvas final : public nsPaintedDisplayItem { + public: + nsDisplayCanvas(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame) + : nsPaintedDisplayItem(aBuilder, aFrame) { + MOZ_COUNT_CTOR(nsDisplayCanvas); + } + MOZ_COUNTED_DTOR_OVERRIDE(nsDisplayCanvas) + + NS_DISPLAY_DECL_NAME("nsDisplayCanvas", TYPE_CANVAS) + + virtual nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder, + bool* aSnap) const override { + *aSnap = false; + nsHTMLCanvasFrame* f = static_cast<nsHTMLCanvasFrame*>(Frame()); + HTMLCanvasElement* canvas = HTMLCanvasElement::FromNode(f->GetContent()); + nsRegion result; + if (canvas->GetIsOpaque()) { + // OK, the entire region painted by the canvas is opaque. But what is + // that region? It's the canvas's "dest rect" (controlled by the + // object-fit/object-position CSS properties), clipped to the container's + // content box (which is what GetBounds() returns). So, we grab those + // rects and intersect them. + nsRect constraintRect = GetBounds(aBuilder, aSnap); + + // Need intrinsic size & ratio, for ComputeObjectDestRect: + nsIntSize canvasSize = f->GetCanvasSize(); + IntrinsicSize intrinsicSize = IntrinsicSizeFromCanvasSize(canvasSize); + AspectRatio intrinsicRatio = IntrinsicRatioFromCanvasSize(canvasSize); + + const nsRect destRect = nsLayoutUtils::ComputeObjectDestRect( + constraintRect, intrinsicSize, intrinsicRatio, f->StylePosition()); + return nsRegion(destRect.Intersect(constraintRect)); + } + return result; + } + + virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, + bool* aSnap) const override { + *aSnap = true; + return Frame()->GetContentRectRelativeToSelf() + ToReferenceFrame(); + } + + virtual bool CreateWebRenderCommands( + mozilla::wr::DisplayListBuilder& aBuilder, + wr::IpcResourceUpdateQueue& aResources, const StackingContextHelper& aSc, + mozilla::layers::RenderRootStateManager* aManager, + nsDisplayListBuilder* aDisplayListBuilder) override { + HTMLCanvasElement* element = + static_cast<HTMLCanvasElement*>(mFrame->GetContent()); + element->HandlePrintCallback(mFrame->PresContext()); + + if (element->IsOffscreen()) { + // If we are offscreen, then we either display via an ImageContainer + // which is updated asynchronously, likely from a worker thread, or a + // CompositableHandle managed inside the compositor process. There is + // nothing to paint until the owner attaches it. + + element->FlushOffscreenCanvas(); + + nsHTMLCanvasFrame* canvasFrame = static_cast<nsHTMLCanvasFrame*>(mFrame); + nsIntSize canvasSizeInPx = canvasFrame->GetCanvasSize(); + IntrinsicSize intrinsicSize = IntrinsicSizeFromCanvasSize(canvasSizeInPx); + AspectRatio intrinsicRatio = IntrinsicRatioFromCanvasSize(canvasSizeInPx); + nsRect area = mFrame->GetContentRectRelativeToSelf() + ToReferenceFrame(); + nsRect dest = nsLayoutUtils::ComputeObjectDestRect( + area, intrinsicSize, intrinsicRatio, mFrame->StylePosition()); + LayoutDeviceRect bounds = LayoutDeviceRect::FromAppUnits( + dest, mFrame->PresContext()->AppUnitsPerDevPixel()); + + RefPtr<ImageContainer> container = element->GetImageContainer(); + if (container) { + MOZ_ASSERT(container->IsAsync()); + aManager->CommandBuilder().PushImage(this, container, aBuilder, + aResources, aSc, bounds, bounds); + return true; + } + + return true; + } + + switch (element->GetCurrentContextType()) { + case CanvasContextType::Canvas2D: + case CanvasContextType::WebGL1: + case CanvasContextType::WebGL2: + case CanvasContextType::WebGPU: { + bool isRecycled; + RefPtr<WebRenderCanvasData> canvasData = + aManager->CommandBuilder() + .CreateOrRecycleWebRenderUserData<WebRenderCanvasData>( + this, &isRecycled); + nsHTMLCanvasFrame* canvasFrame = + static_cast<nsHTMLCanvasFrame*>(mFrame); + if (!canvasFrame->UpdateWebRenderCanvasData(aDisplayListBuilder, + canvasData)) { + return true; + } + WebRenderCanvasRendererAsync* data = canvasData->GetCanvasRenderer(); + MOZ_ASSERT(data); + data->UpdateCompositableClient(); + + // Push IFrame for async image pipeline. + // XXX Remove this once partial display list update is supported. + + nsIntSize canvasSizeInPx = data->GetSize(); + IntrinsicSize intrinsicSize = + IntrinsicSizeFromCanvasSize(canvasSizeInPx); + AspectRatio intrinsicRatio = + IntrinsicRatioFromCanvasSize(canvasSizeInPx); + + nsRect area = + mFrame->GetContentRectRelativeToSelf() + ToReferenceFrame(); + nsRect dest = nsLayoutUtils::ComputeObjectDestRect( + area, intrinsicSize, intrinsicRatio, mFrame->StylePosition()); + + LayoutDeviceRect bounds = LayoutDeviceRect::FromAppUnits( + dest, mFrame->PresContext()->AppUnitsPerDevPixel()); + + // We don't push a stacking context for this async image pipeline here. + // Instead, we do it inside the iframe that hosts the image. As a + // result, a bunch of the calculations normally done as part of that + // stacking context need to be done manually and pushed over to the + // parent side, where it will be done when we build the display list for + // the iframe. That happens in WebRenderCompositableHolder.s2); + aBuilder.PushIFrame(bounds, !BackfaceIsHidden(), + data->GetPipelineId().ref(), + /*ignoreMissingPipelines*/ false); + + LayoutDeviceRect scBounds(LayoutDevicePoint(0, 0), bounds.Size()); + auto filter = wr::ToImageRendering(mFrame->UsedImageRendering()); + auto mixBlendMode = wr::MixBlendMode::Normal; + aManager->WrBridge()->AddWebRenderParentCommand( + OpUpdateAsyncImagePipeline(data->GetPipelineId().value(), scBounds, + VideoInfo::Rotation::kDegree_0, filter, + mixBlendMode)); + break; + } + case CanvasContextType::ImageBitmap: { + nsHTMLCanvasFrame* canvasFrame = + static_cast<nsHTMLCanvasFrame*>(mFrame); + nsIntSize canvasSizeInPx = canvasFrame->GetCanvasSize(); + if (canvasSizeInPx.width <= 0 || canvasSizeInPx.height <= 0) { + return true; + } + bool isRecycled; + RefPtr<WebRenderCanvasData> canvasData = + aManager->CommandBuilder() + .CreateOrRecycleWebRenderUserData<WebRenderCanvasData>( + this, &isRecycled); + if (!canvasFrame->UpdateWebRenderCanvasData(aDisplayListBuilder, + canvasData)) { + canvasData->ClearImageContainer(); + return true; + } + + IntrinsicSize intrinsicSize = + IntrinsicSizeFromCanvasSize(canvasSizeInPx); + AspectRatio intrinsicRatio = + IntrinsicRatioFromCanvasSize(canvasSizeInPx); + + nsRect area = + mFrame->GetContentRectRelativeToSelf() + ToReferenceFrame(); + nsRect dest = nsLayoutUtils::ComputeObjectDestRect( + area, intrinsicSize, intrinsicRatio, mFrame->StylePosition()); + + LayoutDeviceRect bounds = LayoutDeviceRect::FromAppUnits( + dest, mFrame->PresContext()->AppUnitsPerDevPixel()); + + aManager->CommandBuilder().PushImage( + this, canvasData->GetImageContainer(), aBuilder, aResources, aSc, + bounds, bounds); + break; + } + case CanvasContextType::NoContext: + break; + default: + MOZ_ASSERT_UNREACHABLE("unknown canvas context type"); + } + return true; + } + + // FirstContentfulPaint is supposed to ignore "white" canvases. We use + // MaybeModified (if GetContext() was called on the canvas) as a standin for + // "white" + virtual bool IsContentful() const override { + nsHTMLCanvasFrame* f = static_cast<nsHTMLCanvasFrame*>(Frame()); + HTMLCanvasElement* canvas = HTMLCanvasElement::FromNode(f->GetContent()); + return canvas->MaybeModified(); + } + + virtual void Paint(nsDisplayListBuilder* aBuilder, + gfxContext* aCtx) override { + nsHTMLCanvasFrame* f = static_cast<nsHTMLCanvasFrame*>(Frame()); + HTMLCanvasElement* canvas = HTMLCanvasElement::FromNode(f->GetContent()); + + nsRect area = f->GetContentRectRelativeToSelf() + ToReferenceFrame(); + nsIntSize canvasSizeInPx = f->GetCanvasSize(); + + nsPresContext* presContext = f->PresContext(); + canvas->HandlePrintCallback(presContext); + + if (canvasSizeInPx.width <= 0 || canvasSizeInPx.height <= 0 || + area.IsEmpty()) { + return; + } + + IntrinsicSize intrinsicSize = IntrinsicSizeFromCanvasSize(canvasSizeInPx); + AspectRatio intrinsicRatio = IntrinsicRatioFromCanvasSize(canvasSizeInPx); + + nsRect dest = nsLayoutUtils::ComputeObjectDestRect( + area, intrinsicSize, intrinsicRatio, f->StylePosition()); + + gfxContextMatrixAutoSaveRestore saveMatrix(aCtx); + + if (RefPtr<layers::Image> image = canvas->GetAsImage()) { + gfxRect destGFXRect = presContext->AppUnitsToGfxUnits(dest); + + // Transform the canvas into the right place + gfxPoint p = destGFXRect.TopLeft(); + Matrix transform = Matrix::Translation(p.x, p.y); + transform.PreScale(destGFXRect.Width() / canvasSizeInPx.width, + destGFXRect.Height() / canvasSizeInPx.height); + + aCtx->SetMatrix( + gfxUtils::SnapTransformTranslation(aCtx->CurrentMatrix(), nullptr)); + + RefPtr<gfx::SourceSurface> surface = image->GetAsSourceSurface(); + if (!surface || !surface->IsValid()) { + return; + } + gfx::IntSize size = surface->GetSize(); + + transform = gfxUtils::SnapTransform( + transform, gfxRect(0, 0, size.width, size.height), nullptr); + aCtx->Multiply(transform); + + aCtx->GetDrawTarget()->FillRect( + Rect(0, 0, size.width, size.height), + SurfacePattern(surface, ExtendMode::CLAMP, Matrix(), + nsLayoutUtils::GetSamplingFilterForFrame(f))); + return; + } + + if (canvas->IsOffscreen()) { + return; + } + + RefPtr<CanvasRenderer> renderer = new CanvasRenderer(); + if (!canvas->InitializeCanvasRenderer(aBuilder, renderer)) { + return; + } + renderer->FirePreTransactionCallback(); + const auto snapshot = renderer->BorrowSnapshot(); + if (!snapshot) { + return; + } + const auto& surface = snapshot->mSurf; + DrawTarget& dt = *aCtx->GetDrawTarget(); + gfx::Rect destRect = + NSRectToSnappedRect(dest, presContext->AppUnitsPerDevPixel(), dt); + + if (!renderer->YIsDown()) { + // Calculate y-coord that is as far below the bottom of destGFXRect as + // the origin was above the top, then reflect about that. + float y = destRect.Y() + destRect.YMost(); + Matrix transform = Matrix::Translation(0.0f, y).PreScale(1.0f, -1.0f); + aCtx->Multiply(transform); + } + + const auto& srcRect = surface->GetRect(); + dt.DrawSurface( + surface, destRect, + Rect(float(srcRect.X()), float(srcRect.Y()), float(srcRect.Width()), + float(srcRect.Height())), + DrawSurfaceOptions(nsLayoutUtils::GetSamplingFilterForFrame(f))); + + renderer->FireDidTransactionCallback(); + renderer->ResetDirty(); + } +}; + +nsIFrame* NS_NewHTMLCanvasFrame(PresShell* aPresShell, ComputedStyle* aStyle) { + return new (aPresShell) + nsHTMLCanvasFrame(aStyle, aPresShell->GetPresContext()); +} + +NS_QUERYFRAME_HEAD(nsHTMLCanvasFrame) + NS_QUERYFRAME_ENTRY(nsHTMLCanvasFrame) +NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame) + +NS_IMPL_FRAMEARENA_HELPERS(nsHTMLCanvasFrame) + +void nsHTMLCanvasFrame::Destroy(DestroyContext& aContext) { + if (IsPrimaryFrame()) { + HTMLCanvasElement::FromNode(*mContent)->ResetPrintCallback(); + } + nsContainerFrame::Destroy(aContext); +} + +nsHTMLCanvasFrame::~nsHTMLCanvasFrame() = default; + +nsIntSize nsHTMLCanvasFrame::GetCanvasSize() const { + nsIntSize size(0, 0); + HTMLCanvasElement* canvas = HTMLCanvasElement::FromNodeOrNull(GetContent()); + if (canvas) { + size = canvas->GetSize(); + MOZ_ASSERT(size.width >= 0 && size.height >= 0, + "we should've required <canvas> width/height attrs to be " + "unsigned (non-negative) values"); + } else { + MOZ_ASSERT_UNREACHABLE("couldn't get canvas size"); + } + + return size; +} + +/* virtual */ +nscoord nsHTMLCanvasFrame::GetMinISize(gfxContext* aRenderingContext) { + // XXX The caller doesn't account for constraints of the height, + // min-height, and max-height properties. + nscoord result; + if (Maybe<nscoord> containISize = ContainIntrinsicISize()) { + result = *containISize; + } else { + bool vertical = GetWritingMode().IsVertical(); + result = nsPresContext::CSSPixelsToAppUnits( + vertical ? GetCanvasSize().height : GetCanvasSize().width); + } + DISPLAY_MIN_INLINE_SIZE(this, result); + return result; +} + +/* virtual */ +nscoord nsHTMLCanvasFrame::GetPrefISize(gfxContext* aRenderingContext) { + // XXX The caller doesn't account for constraints of the height, + // min-height, and max-height properties. + nscoord result; + if (Maybe<nscoord> containISize = ContainIntrinsicISize()) { + result = *containISize; + } else { + bool vertical = GetWritingMode().IsVertical(); + result = nsPresContext::CSSPixelsToAppUnits( + vertical ? GetCanvasSize().height : GetCanvasSize().width); + } + DISPLAY_PREF_INLINE_SIZE(this, result); + return result; +} + +/* virtual */ +IntrinsicSize nsHTMLCanvasFrame::GetIntrinsicSize() { + const auto containAxes = GetContainSizeAxes(); + IntrinsicSize size = containAxes.IsBoth() + ? IntrinsicSize(0, 0) + : IntrinsicSizeFromCanvasSize(GetCanvasSize()); + return containAxes.ContainIntrinsicSize(size, *this); +} + +/* virtual */ +AspectRatio nsHTMLCanvasFrame::GetIntrinsicRatio() const { + if (GetContainSizeAxes().IsAny()) { + return AspectRatio(); + } + + return IntrinsicRatioFromCanvasSize(GetCanvasSize()); +} + +/* virtual */ +nsIFrame::SizeComputationResult nsHTMLCanvasFrame::ComputeSize( + gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize, + nscoord aAvailableISize, const LogicalSize& aMargin, + const LogicalSize& aBorderPadding, const StyleSizeOverrides& aSizeOverrides, + ComputeSizeFlags aFlags) { + return {ComputeSizeWithIntrinsicDimensions( + aRenderingContext, aWM, GetIntrinsicSize(), GetAspectRatio(), + aCBSize, aMargin, aBorderPadding, aSizeOverrides, aFlags), + AspectRatioUsage::None}; +} + +void nsHTMLCanvasFrame::Reflow(nsPresContext* aPresContext, + ReflowOutput& aMetrics, + const ReflowInput& aReflowInput, + nsReflowStatus& aStatus) { + MarkInReflow(); + DO_GLOBAL_REFLOW_COUNT("nsHTMLCanvasFrame"); + DISPLAY_REFLOW(aPresContext, this, aReflowInput, aMetrics, aStatus); + MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!"); + NS_FRAME_TRACE( + NS_FRAME_TRACE_CALLS, + ("enter nsHTMLCanvasFrame::Reflow: availSize=%d,%d", + aReflowInput.AvailableWidth(), aReflowInput.AvailableHeight())); + + MOZ_ASSERT(HasAnyStateBits(NS_FRAME_IN_REFLOW), "frame is not in reflow"); + + WritingMode wm = aReflowInput.GetWritingMode(); + const LogicalSize finalSize = aReflowInput.ComputedSizeWithBorderPadding(wm); + + aMetrics.SetSize(wm, finalSize); + aMetrics.SetOverflowAreasToDesiredBounds(); + FinishAndStoreOverflow(&aMetrics); + + // Reflow the single anon block child. + nsReflowStatus childStatus; + nsIFrame* childFrame = mFrames.FirstChild(); + WritingMode childWM = childFrame->GetWritingMode(); + LogicalSize availSize = aReflowInput.ComputedSize(childWM); + availSize.BSize(childWM) = NS_UNCONSTRAINEDSIZE; + NS_ASSERTION(!childFrame->GetNextSibling(), "HTML canvas should have 1 kid"); + ReflowOutput childDesiredSize(aReflowInput.GetWritingMode()); + ReflowInput childReflowInput(aPresContext, aReflowInput, childFrame, + availSize); + ReflowChild(childFrame, aPresContext, childDesiredSize, childReflowInput, 0, + 0, ReflowChildFlags::Default, childStatus, nullptr); + FinishReflowChild(childFrame, aPresContext, childDesiredSize, + &childReflowInput, 0, 0, ReflowChildFlags::Default); + + NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS, + ("exit nsHTMLCanvasFrame::Reflow: size=%d,%d", + aMetrics.ISize(wm), aMetrics.BSize(wm))); +} + +bool nsHTMLCanvasFrame::UpdateWebRenderCanvasData( + nsDisplayListBuilder* aBuilder, WebRenderCanvasData* aCanvasData) { + HTMLCanvasElement* element = static_cast<HTMLCanvasElement*>(GetContent()); + return element->UpdateWebRenderCanvasData(aBuilder, aCanvasData); +} + +void nsHTMLCanvasFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder, + const nsDisplayListSet& aLists) { + if (!IsVisibleForPainting()) return; + + DisplayBorderBackgroundOutline(aBuilder, aLists); + + if (HidesContent()) { + DisplaySelectionOverlay(aBuilder, aLists.Content(), + nsISelectionDisplay::DISPLAY_IMAGES); + return; + } + + uint32_t clipFlags = + nsStyleUtil::ObjectPropsMightCauseOverflow(StylePosition()) + ? 0 + : DisplayListClipState::ASSUME_DRAWING_RESTRICTED_TO_CONTENT_RECT; + + DisplayListClipState::AutoClipContainingBlockDescendantsToContentBox clip( + aBuilder, this, clipFlags); + + aLists.Content()->AppendNewToTop<nsDisplayCanvas>(aBuilder, this); + + DisplaySelectionOverlay(aBuilder, aLists.Content(), + nsISelectionDisplay::DISPLAY_IMAGES); +} + +void nsHTMLCanvasFrame::AppendDirectlyOwnedAnonBoxes( + nsTArray<OwnedAnonBox>& aResult) { + MOZ_ASSERT(mFrames.FirstChild(), "Must have our canvas content anon box"); + MOZ_ASSERT(!mFrames.FirstChild()->GetNextSibling(), + "Must only have our canvas content anon box"); + aResult.AppendElement(OwnedAnonBox(mFrames.FirstChild())); +} + +void nsHTMLCanvasFrame::UnionChildOverflow( + mozilla::OverflowAreas& aOverflowAreas) { + // Our one child (the canvas content anon box) is unpainted and isn't relevant + // for child-overflow purposes. So we need to provide our own trivial impl to + // avoid receiving the child-considering impl that we would otherwise inherit. +} + +#ifdef ACCESSIBILITY +a11y::AccType nsHTMLCanvasFrame::AccessibleType() { + return a11y::eHTMLCanvasType; +} +#endif + +#ifdef DEBUG_FRAME_DUMP +nsresult nsHTMLCanvasFrame::GetFrameName(nsAString& aResult) const { + return MakeFrameName(u"HTMLCanvas"_ns, aResult); +} +#endif |