Source code

Revision control

Copy as Markdown

Other Tools

/* -*- 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 */
/* rendering object that goes directly inside the document's scrollbars */
#include "nsCanvasFrame.h"
#include "gfxContext.h"
#include "gfxPlatform.h"
#include "gfxUtils.h"
#include "mozilla/BasePrincipal.h"
#include "mozilla/ComputedStyle.h"
#include "mozilla/dom/AnonymousContent.h"
#include "mozilla/layers/RenderRootStateManager.h"
#include "mozilla/layers/StackingContextHelper.h"
#include "mozilla/PresShell.h"
#include "mozilla/StaticPrefs_browser.h"
#include "mozilla/StaticPrefs_layout.h"
#include "nsContainerFrame.h"
#include "nsContentCreatorFunctions.h"
#include "nsCSSFrameConstructor.h"
#include "nsCSSRendering.h"
#include "nsDisplayList.h"
#include "nsFrameManager.h"
#include "nsGkAtoms.h"
#include "nsIFrameInlines.h"
#include "nsIScrollableFrame.h"
#include "nsPresContext.h"
using namespace mozilla;
using namespace mozilla::dom;
using namespace mozilla::layout;
using namespace mozilla::gfx;
using namespace mozilla::layers;
nsCanvasFrame* NS_NewCanvasFrame(PresShell* aPresShell, ComputedStyle* aStyle) {
return new (aPresShell) nsCanvasFrame(aStyle, aPresShell->GetPresContext());
nsIPopupContainer* nsIPopupContainer::GetPopupContainer(PresShell* aPresShell) {
return aPresShell ? aPresShell->GetCanvasFrame() : nullptr;
void nsCanvasFrame::ShowCustomContentContainer() {
if (mCustomContentContainer) {
mCustomContentContainer->UnsetAttr(kNameSpaceID_None, nsGkAtoms::hidden,
void nsCanvasFrame::HideCustomContentContainer() {
if (mCustomContentContainer) {
mCustomContentContainer->SetAttr(kNameSpaceID_None, nsGkAtoms::hidden,
u"true"_ns, true);
// Do this off a script-runner because some anon content might load CSS which we
// don't want to deal with while doing frame construction.
void InsertAnonymousContentInContainer(Document& aDoc, Element& aContainer) {
if (!aContainer.IsInComposedDoc() || aDoc.GetAnonymousContents().IsEmpty()) {
for (RefPtr<AnonymousContent>& anonContent : aDoc.GetAnonymousContents()) {
if (nsCOMPtr<nsINode> parent = anonContent->Host()->GetParentNode()) {
// Parent had better be an old custom content container already
// removed from a reframe. Forget about it since we're about to get
// inserted in a new one.
// TODO(emilio): Maybe we should extend PostDestroyData and do this
// stuff there instead, or something...
MOZ_ASSERT(parent != &aContainer);
parent->RemoveChildNode(anonContent->Host(), true);
aContainer.AppendChildTo(anonContent->Host(), true, IgnoreErrors());
// Flush frames now. This is really sadly needed, but otherwise stylesheets
// inserted by the above DOM changes might not be processed in time for layout
// to run.
// FIXME(emilio): This is because we have a script-running checkpoint just
// after ProcessPendingRestyles but before DoReflow. That seems wrong! Ideally
// the whole layout / styling pass should be atomic.
nsresult nsCanvasFrame::CreateAnonymousContent(
nsTArray<ContentInfo>& aElements) {
if (!mContent) {
return NS_OK;
Document* doc = mContent->OwnerDoc();
// Create the custom content container.
mCustomContentContainer = doc->CreateHTMLElement(nsGkAtoms::div);
#ifdef DEBUG
// We restyle our mCustomContentContainer, even though it's root anonymous
// content. Normally that's not OK because the frame constructor doesn't know
// how to order the frame tree in such cases, but we make this work for this
// particular case, so it's OK.
#endif // DEBUG
nsGkAtoms::docLevelNativeAnonymousContent, reinterpret_cast<void*>(true));
// This will usually be done by the caller, but in this case we do it here,
// since we reuse the document's AnoymousContent list, and those survive
// across reframes and thus may already be flagged as being in an anonymous
// subtree. We don't really want to have this semi-broken state where
// anonymous nodes have a non-anonymous.
// Do not create an accessible object for the container.
mCustomContentContainer->SetAttr(kNameSpaceID_None, nsGkAtoms::role,
u"presentation"_ns, false);
mCustomContentContainer->SetAttr(kNameSpaceID_None, nsGkAtoms::_class,
u"moz-custom-content-container"_ns, false);
// Only create a frame for mCustomContentContainer if it has some children.
if (doc->GetAnonymousContents().IsEmpty()) {
} else {
[doc = RefPtr{doc}, container = RefPtr{mCustomContentContainer.get()}] {
InsertAnonymousContentInContainer(*doc, *container);
// Create a default tooltip element for system privileged documents.
if (XRE_IsParentProcess() && doc->NodePrincipal()->IsSystemPrincipal()) {
nsNodeInfoManager* nodeInfoManager = doc->NodeInfoManager();
RefPtr<NodeInfo> nodeInfo = nodeInfoManager->GetNodeInfo(
nsGkAtoms::tooltip, nullptr, kNameSpaceID_XUL, nsINode::ELEMENT_NODE);
nsresult rv = NS_NewXULElement(getter_AddRefs(mTooltipContent),
nodeInfo.forget(), dom::NOT_FROM_PARSER);
mTooltipContent->SetAttr(kNameSpaceID_None, nsGkAtoms::_default, u"true"_ns,
// Set the page attribute so XULTooltipElement::PostHandleEvent will find
// the text for the tooltip from the currently hovered element.
mTooltipContent->SetAttr(kNameSpaceID_None, nsGkAtoms::page, u"true"_ns,
#ifdef DEBUG
for (auto& element : aElements) {
"NAC from the canvas frame needs to be document-level, otherwise"
" it (1) inherits from the document which is unexpected, and (2)"
" StyleChildrenIterator won't be able to find it properly");
return NS_OK;
void nsCanvasFrame::AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements,
uint32_t aFilter) {
if (mCustomContentContainer) {
if (mTooltipContent) {
void nsCanvasFrame::Destroy(DestroyContext& aContext) {
nsIScrollableFrame* sf = PresShell()->GetRootScrollFrameAsScrollable();
if (sf) {
if (mTooltipContent) {
void nsCanvasFrame::ScrollPositionWillChange(nscoord aX, nscoord aY) {
if (mDoPaintFocus) {
mDoPaintFocus = false;
nsCanvasFrame::SetHasFocus(bool aHasFocus) {
if (mDoPaintFocus != aHasFocus) {
mDoPaintFocus = aHasFocus;
if (!mAddedScrollPositionListener) {
nsIScrollableFrame* sf = PresShell()->GetRootScrollFrameAsScrollable();
if (sf) {
mAddedScrollPositionListener = true;
return NS_OK;
void nsCanvasFrame::SetInitialChildList(ChildListID aListID,
nsFrameList&& aChildList) {
NS_ASSERTION(aListID != FrameChildListID::Principal || aChildList.IsEmpty() ||
"Primary child list can have at most one frame in it");
nsContainerFrame::SetInitialChildList(aListID, std::move(aChildList));
void nsCanvasFrame::AppendFrames(ChildListID aListID,
nsFrameList&& aFrameList) {
#ifdef DEBUG
MOZ_ASSERT(aListID == FrameChildListID::Principal, "unexpected child list");
if (!mFrames.IsEmpty()) {
for (nsIFrame* f : aFrameList) {
// We only allow native anonymous child frames to be in principal child
// list in canvas frame.
"invalid child list");
nsContainerFrame::AppendFrames(aListID, std::move(aFrameList));
void nsCanvasFrame::InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame,
const nsLineList::iterator* aPrevFrameLine,
nsFrameList&& aFrameList) {
// Because we only support a single child frame inserting is the same
// as appending
MOZ_ASSERT(!aPrevFrame, "unexpected previous sibling frame");
AppendFrames(aListID, std::move(aFrameList));
#ifdef DEBUG
void nsCanvasFrame::RemoveFrame(DestroyContext& aContext, ChildListID aListID,
nsIFrame* aOldFrame) {
MOZ_ASSERT(aListID == FrameChildListID::Principal, "unexpected child list");
nsContainerFrame::RemoveFrame(aContext, aListID, aOldFrame);
nsRect nsCanvasFrame::CanvasArea() const {
// Not clear which overflow rect we want here, but it probably doesn't
// matter.
nsRect result(InkOverflowRect());
nsIScrollableFrame* scrollableFrame = do_QueryFrame(GetParent());
if (scrollableFrame) {
nsRect portRect = scrollableFrame->GetScrollPortRect();
result.UnionRect(result, nsRect(nsPoint(0, 0), portRect.Size()));
return result;
Element* nsCanvasFrame::GetDefaultTooltip() { return mTooltipContent; }
void nsDisplayCanvasBackgroundColor::Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx) {
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
nsPoint offset = ToReferenceFrame();
nsRect bgClipRect = frame->CanvasArea() + offset;
if (NS_GET_A(mColor) > 0) {
DrawTarget* drawTarget = aCtx->GetDrawTarget();
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
Rect devPxRect =
NSRectToSnappedRect(bgClipRect, appUnitsPerDevPixel, *drawTarget);
drawTarget->FillRect(devPxRect, ColorPattern(ToDeviceColor(mColor)));
bool nsDisplayCanvasBackgroundColor::CreateWebRenderCommands(
mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc, RenderRootStateManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) {
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
nsPoint offset = ToReferenceFrame();
nsRect bgClipRect = frame->CanvasArea() + offset;
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
LayoutDeviceRect rect =
LayoutDeviceRect::FromAppUnits(bgClipRect, appUnitsPerDevPixel);
wr::LayoutRect r = wr::ToLayoutRect(rect);
aBuilder.PushRect(r, r, !BackfaceIsHidden(), false, false,
return true;
void nsDisplayCanvasBackgroundColor::WriteDebugInfo(
std::stringstream& aStream) {
aStream << " (rgba " << (int)NS_GET_R(mColor) << "," << (int)NS_GET_G(mColor)
<< "," << (int)NS_GET_B(mColor) << "," << (int)NS_GET_A(mColor)
<< ")";
void nsDisplayCanvasBackgroundImage::Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx) {
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
nsPoint offset = ToReferenceFrame();
nsRect bgClipRect = frame->CanvasArea() + offset;
PaintInternal(aBuilder, aCtx, GetPaintRect(aBuilder, aCtx), &bgClipRect);
bool nsDisplayCanvasBackgroundImage::IsSingleFixedPositionImage(
nsDisplayListBuilder* aBuilder, const nsRect& aClipRect,
gfxRect* aDestRect) {
if (!mBackgroundStyle) return false;
if (mBackgroundStyle->StyleBackground()->mImage.mLayers.Length() != 1)
return false;
nsPresContext* presContext = mFrame->PresContext();
uint32_t flags = aBuilder->GetBackgroundPaintFlags();
nsRect borderArea = nsRect(ToReferenceFrame(), mFrame->GetSize());
const nsStyleImageLayers::Layer& layer =
if (layer.mAttachment != StyleImageLayerAttachment::Fixed) return false;
nsBackgroundLayerState state = nsCSSRendering::PrepareImageLayer(
presContext, mFrame, flags, borderArea, aClipRect, layer);
// We only care about images here, not gradients.
if (!mIsRasterImage) return false;
int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();
*aDestRect =
nsLayoutUtils::RectToGfxRect(state.mFillArea, appUnitsPerDevPixel);
return true;
void nsDisplayCanvasThemedBackground::Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx) {
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
nsPoint offset = ToReferenceFrame();
nsRect bgClipRect = frame->CanvasArea() + offset;
PaintInternal(aBuilder, aCtx, GetPaintRect(aBuilder, aCtx), &bgClipRect);
* A display item to paint the focus ring for the document.
* The only reason this can't use nsDisplayGeneric is overriding GetBounds.
class nsDisplayCanvasFocus : public nsPaintedDisplayItem {
nsDisplayCanvasFocus(nsDisplayListBuilder* aBuilder, nsCanvasFrame* aFrame)
: nsPaintedDisplayItem(aBuilder, aFrame) {
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
bool* aSnap) const override {
*aSnap = false;
// This is an overestimate, but that's not a problem.
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
return frame->CanvasArea() + ToReferenceFrame();
virtual void Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx) override {
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
frame->PaintFocus(aCtx->GetDrawTarget(), ToReferenceFrame());
void nsCanvasFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsDisplayListSet& aLists) {
if (GetPrevInFlow()) {
DisplayOverflowContainers(aBuilder, aLists);
// Force a background to be shown. We may have a background propagated to us,
// in which case StyleBackground wouldn't have the right background
// and the code in nsIFrame::DisplayBorderBackgroundOutline might not give us
// a background.
// We don't have any border or outline, and our background draws over
// the overflow area, so just add nsDisplayCanvasBackground instead of
// calling DisplayBorderBackgroundOutline.
if (IsVisibleForPainting()) {
ComputedStyle* bg = nullptr;
nsIFrame* dependentFrame = nullptr;
bool isThemed = IsThemed();
if (!isThemed) {
dependentFrame = nsCSSRendering::FindBackgroundFrame(this);
if (dependentFrame) {
bg = dependentFrame->Style();
if (dependentFrame == this) {
dependentFrame = nullptr;
if (isThemed) {
->AppendNewToTop<nsDisplayCanvasThemedBackground>(aBuilder, this);
if (!bg) {
const ActiveScrolledRoot* asr = aBuilder->CurrentActiveScrolledRoot();
bool needBlendContainer = false;
nsDisplayListBuilder::AutoContainerASRTracker contASRTracker(aBuilder);
const bool suppressBackgroundImage = [&] {
// Handle print settings.
if (!ComputeShouldPaintBackground().mImage) {
return true;
// In high-contrast-mode, we suppress background-image on the canvas frame
// (even when backplating), because users expect site backgrounds to
// conform to their HCM background color when a solid color is rendered,
// and some websites use solid-color images instead of an overwritable
// background color.
if (PresContext()->ForcingColors() &&
browser_display_suppress_canvas_background_image_on_forced_colors()) {
return true;
return false;
nsDisplayList layerItems(aBuilder);
// Create separate items for each background layer.
const nsStyleImageLayers& layers = bg->StyleBackground()->mImage;
if (layers.mLayers[i].mImage.IsNone() || suppressBackgroundImage) {
if (layers.mLayers[i].mBlendMode != StyleBlend::Normal) {
needBlendContainer = true;
nsRect bgRect =
GetRectRelativeToSelf() + aBuilder->ToReferenceFrame(this);
const ActiveScrolledRoot* thisItemASR = asr;
nsDisplayList thisItemList(aBuilder);
nsDisplayBackgroundImage::InitData bgData =
nsDisplayBackgroundImage::GetInitData(aBuilder, this, i, bgRect, bg);
if (bgData.shouldFixToViewport) {
auto* displayData = aBuilder->GetCurrentFixedBackgroundDisplayData();
nsDisplayListBuilder::AutoBuildingDisplayList buildingDisplayList(
aBuilder, this, aBuilder->GetVisibleRect(),
DisplayListClipState::AutoSaveRestore clipState(aBuilder);
nsDisplayListBuilder::AutoCurrentActiveScrolledRootSetter asrSetter(
if (displayData) {
const nsPoint offset = GetOffsetTo(PresShell()->GetRootFrame());
aBuilder->SetVisibleRect(displayData->mVisibleRect + offset);
aBuilder->SetDirtyRect(displayData->mDirtyRect + offset);
thisItemASR = displayData->mContainingBlockActiveScrolledRoot;
nsDisplayCanvasBackgroundImage* bgItem = nullptr;
DisplayListClipState::AutoSaveRestore bgImageClip(aBuilder);
bgItem = MakeDisplayItemWithIndex<nsDisplayCanvasBackgroundImage>(
aBuilder, this, /* aIndex = */ i, bgData);
if (bgItem) {
bgItem->SetDependentFrame(aBuilder, dependentFrame);
if (bgItem) {
aBuilder, this, nullptr, bgItem, i, asr));
} else {
nsDisplayCanvasBackgroundImage* bgItem =
aBuilder, this, /* aIndex = */ i, bgData);
if (bgItem) {
bgItem->SetDependentFrame(aBuilder, dependentFrame);
if (layers.mLayers[i].mBlendMode != StyleBlend::Normal) {
DisplayListClipState::AutoSaveRestore blendClip(aBuilder);
aBuilder, this, i + 1, &thisItemList, layers.mLayers[i].mBlendMode,
thisItemASR, true);
bool hasFixedBottomLayer =
layers.mImageCount > 0 &&
layers.mLayers[0].mAttachment == StyleImageLayerAttachment::Fixed;
if (!hasFixedBottomLayer || needBlendContainer) {
// Put a scrolled background color item in place, at the bottom of the
// list. The color of this item will be filled in during
// PresShell::AddCanvasBackgroundColorItem.
// Do not add this item if there's a fixed background image at the bottom
// (unless we have to, for correct blending); with a fixed background,
// it's better to allow the fixed background image to combine itself with
// a non-scrolled background color directly underneath, rather than
// interleaving the two with a scrolled background color.
// PresShell::AddCanvasBackgroundColorItem makes sure there always is a
// non-scrolled background color item at the bottom.
aBuilder, this);
if (needBlendContainer) {
const ActiveScrolledRoot* containerASR = contASRTracker.GetContainerASR();
DisplayListClipState::AutoSaveRestore blendContainerClip(aBuilder);
aBuilder, this, nullptr, aLists.BorderBackground(),
for (nsIFrame* kid : PrincipalChildList()) {
// Put our child into its own pseudo-stack.
BuildDisplayListForChild(aBuilder, kid, aLists);
if (!mDoPaintFocus) return;
// Only paint the focus if we're visible
if (!StyleVisibility()->IsVisible()) return;
aLists.Outlines()->AppendNewToTop<nsDisplayCanvasFocus>(aBuilder, this);
void nsCanvasFrame::PaintFocus(DrawTarget* aDrawTarget, nsPoint aPt) {
nsRect focusRect(aPt, GetSize());
nsIScrollableFrame* scrollableFrame = do_QueryFrame(GetParent());
if (scrollableFrame) {
nsRect portRect = scrollableFrame->GetScrollPortRect();
focusRect.width = portRect.width;
focusRect.height = portRect.height;
// XXX use the root frame foreground color, but should we find BODY frame
// for HTML documents?
nsIFrame* root = mFrames.FirstChild();
const auto* text = root ? root->StyleText() : StyleText();
nsCSSRendering::PaintFocus(PresContext(), aDrawTarget, focusRect,
/* virtual */
nscoord nsCanvasFrame::GetMinISize(gfxContext* aRenderingContext) {
return mFrames.IsEmpty()
? 0
: mFrames.FirstChild()->GetMinISize(aRenderingContext);
/* virtual */
nscoord nsCanvasFrame::GetPrefISize(gfxContext* aRenderingContext) {
return mFrames.IsEmpty()
? 0
: mFrames.FirstChild()->GetPrefISize(aRenderingContext);
void nsCanvasFrame::Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) {
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
nsCanvasFrame* prevCanvasFrame = static_cast<nsCanvasFrame*>(GetPrevInFlow());
if (prevCanvasFrame) {
AutoFrameListPtr overflow(aPresContext,
if (overflow) {
"must have doc root as canvas frame's only child");
nsContainerFrame::ReparentFrameViewList(*overflow, prevCanvasFrame, this);
// Prepend overflow to the our child list. There may already be
// children placeholders for fixed-pos elements, which don't get
// reflowed but must not be lost until the canvas frame is destroyed.
mFrames.InsertFrames(this, nullptr, std::move(*overflow));
// Set our size up front, since some parts of reflow depend on it
// being already set. Note that the computed height may be
// unconstrained; that's ok. Consumers should watch out for that.
// Reflow our children. Typically, we only have one child - the root
// element's frame or a placeholder for that frame, if the root element
// is abs-pos or fixed-pos. Note that this child might be missing though
// if that frame was Complete in one of our earlier continuations. This
// happens when we create additional pages purely to make room for painting
// overflow (painted by BuildPreviousPageOverflow in nsPageFrame.cpp).
// We may have additional children which are placeholders for continuations
// of fixed-pos content, see nsCSSFrameConstructor::ReplicateFixedFrames.
const WritingMode wm = aReflowInput.GetWritingMode();
aDesiredSize.SetSize(wm, aReflowInput.ComputedSize());
if (aReflowInput.ComputedBSize() == NS_UNCONSTRAINEDSIZE) {
// Set the block-size to zero for now in case we don't have any non-
// placeholder children that would update the size in the loop below.
aDesiredSize.BSize(wm) = nscoord(0);
nsIFrame* nextKid = nullptr;
for (auto* kidFrame = mFrames.FirstChild(); kidFrame; kidFrame = nextKid) {
nextKid = kidFrame->GetNextSibling();
ReflowOutput kidDesiredSize(aReflowInput);
bool kidDirty = kidFrame->HasAnyStateBits(NS_FRAME_IS_DIRTY);
WritingMode kidWM = kidFrame->GetWritingMode();
auto availableSize = aReflowInput.AvailableSize(kidWM);
nscoord bOffset = 0;
nscoord canvasBSizeSum = 0;
if (prevCanvasFrame && availableSize.BSize(kidWM) != NS_UNCONSTRAINEDSIZE &&
!kidFrame->IsPlaceholderFrame() &&
StaticPrefs::layout_display_list_improve_fragmentation()) {
for (auto* pif = prevCanvasFrame; pif;
pif = static_cast<nsCanvasFrame*>(pif->GetPrevInFlow())) {
canvasBSizeSum += pif->BSize(kidWM);
auto* pifChild = pif->PrincipalChildList().FirstChild();
if (pifChild) {
nscoord layoutOverflow = pifChild->BSize(kidWM) - canvasBSizeSum;
// A negative value means that the :root frame does not fill
// the canvas. In this case we can't determine the offset exactly
// so we use the end edge of the scrollable overflow as the offset
// instead. This will likely push down the content below where it
// should be placed, creating a gap. That's preferred over making
// content overlap which would otherwise occur.
// See layout/reftests/pagination/inline-block-slice-7.html for an
// example of this.
if (layoutOverflow < 0) {
LogicalRect so(kidWM, pifChild->ScrollableOverflowRect(),
layoutOverflow = so.BEnd(kidWM) - canvasBSizeSum;
bOffset = std::max(bOffset, layoutOverflow);
availableSize.BSize(kidWM) -= bOffset;
if (MOZ_LIKELY(availableSize.BSize(kidWM) > 0)) {
ReflowInput kidReflowInput(aPresContext, aReflowInput, kidFrame,
if (aReflowInput.IsBResizeForWM(kidReflowInput.GetWritingMode()) &&
// Tell our kid it's being block-dir resized too. Bit of a
// hack for framesets.
nsSize containerSize = aReflowInput.ComputedPhysicalSize();
LogicalMargin margin = kidReflowInput.ComputedLogicalMargin(kidWM);
LogicalPoint kidPt(kidWM, margin.IStart(kidWM), margin.BStart(kidWM));
(kidWM.IsOrthogonalTo(wm) ? kidPt.I(kidWM) : kidPt.B(kidWM)) += bOffset;
nsReflowStatus kidStatus;
ReflowChild(kidFrame, aPresContext, kidDesiredSize, kidReflowInput, kidWM,
kidPt, containerSize, ReflowChildFlags::Default, kidStatus);
FinishReflowChild(kidFrame, aPresContext, kidDesiredSize, &kidReflowInput,
kidWM, kidPt, containerSize,
if (!kidStatus.IsFullyComplete()) {
nsIFrame* nextFrame = kidFrame->GetNextInFlow();
NS_ASSERTION(nextFrame || kidStatus.NextInFlowNeedsReflow(),
"If it's incomplete and has no nif yet, it must flag a "
"nif reflow.");
if (!nextFrame) {
nextFrame = aPresContext->PresShell()
->CreateContinuingFrame(kidFrame, this);
SetOverflowFrames(nsFrameList(nextFrame, nextFrame));
// Root overflow containers will be normal children of
// the canvas frame, but that's ok because there
// aren't any other frames we need to isolate them from
// during reflow.
if (kidStatus.IsOverflowIncomplete()) {
// If the child frame was just inserted, then we're responsible for making
// sure it repaints
if (kidDirty) {
// But we have a new child, which will affect our background, so
// invalidate our whole rect.
// Note: Even though we request to be sized to our child's size, our
// scroll frame ensures that we are always the size of the viewport.
// Also note: GetPosition() on a CanvasFrame is always going to return
// (0, 0). We only want to invalidate GetRect() since Get*OverflowRect()
// could also include overflow to our top and left (out of the viewport)
// which doesn't need to be painted.
nsIFrame* viewport = PresShell()->GetRootFrame();
// Return our desired size. Normally it's what we're told, but sometimes
// we can be given an unconstrained block-size (when a window is
// sizing-to-content), and we should compute our desired block-size. This
// is done by PresShell::ResizeReflow, when given the BSizeLimit flag.
// We do this here rather than at the viewport frame, because the canvas
// is what draws the background, so it can extend a little bit more than
// the real content without visual glitches, realistically.
if (aReflowInput.ComputedBSize() == NS_UNCONSTRAINEDSIZE &&
!kidFrame->IsPlaceholderFrame()) {
LogicalSize finalSize = aReflowInput.ComputedSize();
finalSize.BSize(wm) = nsPresContext::RoundUpAppUnitsToCSSPixel(
kidFrame->GetLogicalSize(wm).BSize(wm) +
aDesiredSize.SetSize(wm, finalSize);
aDesiredSize.mOverflowAreas.UnionWith(kidDesiredSize.mOverflowAreas +
} else if (kidFrame->IsPlaceholderFrame()) {
// Placeholders always fit even if there's no available block-size left.
} else {
// This only occurs in paginated mode. There is no available space on
// this page due to reserving space for overflow from a previous page,
// so we push our child to the next page. Note that we can have some
// placeholders for fixed pos. frames in mFrames too, so we need to be
// careful to only push `kidFrame`.
SetOverflowFrames(nsFrameList(kidFrame, kidFrame));
if (prevCanvasFrame) {
ReflowOverflowContainerChildren(aPresContext, aReflowInput,
ReflowChildFlags::Default, aStatus);
FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput,
NS_FRAME_TRACE_REFLOW_OUT("nsCanvasFrame::Reflow", aStatus);
nsresult nsCanvasFrame::GetContentForEvent(const WidgetEvent* aEvent,
nsIContent** aContent) {
nsresult rv = nsIFrame::GetContentForEvent(aEvent, aContent);
if (NS_FAILED(rv) || !*aContent) {
nsIFrame* kid = mFrames.FirstChild();
if (kid) {
rv = kid->GetContentForEvent(aEvent, aContent);
return rv;
nsresult nsCanvasFrame::GetFrameName(nsAString& aResult) const {
return MakeFrameName(u"Canvas"_ns, aResult);