summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsCanvasFrame.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/generic/nsCanvasFrame.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/generic/nsCanvasFrame.cpp')
-rw-r--r--layout/generic/nsCanvasFrame.cpp744
1 files changed, 744 insertions, 0 deletions
diff --git a/layout/generic/nsCanvasFrame.cpp b/layout/generic/nsCanvasFrame.cpp
new file mode 100644
index 000000000..70a2117cf
--- /dev/null
+++ b/layout/generic/nsCanvasFrame.cpp
@@ -0,0 +1,744 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 that goes directly inside the document's scrollbars */
+
+#include "nsCanvasFrame.h"
+
+#include "AccessibleCaretEventHub.h"
+#include "gfxUtils.h"
+#include "nsContainerFrame.h"
+#include "nsCSSRendering.h"
+#include "nsPresContext.h"
+#include "nsStyleContext.h"
+#include "nsRenderingContext.h"
+#include "nsGkAtoms.h"
+#include "nsPresShell.h"
+#include "nsIPresShell.h"
+#include "nsDisplayList.h"
+#include "nsCSSFrameConstructor.h"
+#include "nsFrameManager.h"
+#include "gfxPlatform.h"
+#include "nsPrintfCString.h"
+#include "mozilla/dom/AnonymousContent.h"
+// for focus
+#include "nsIScrollableFrame.h"
+#ifdef DEBUG_CANVAS_FOCUS
+#include "nsIDocShell.h"
+#endif
+
+//#define DEBUG_CANVAS_FOCUS
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::layout;
+using namespace mozilla::gfx;
+
+nsCanvasFrame*
+NS_NewCanvasFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+ return new (aPresShell) nsCanvasFrame(aContext);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsCanvasFrame)
+
+NS_QUERYFRAME_HEAD(nsCanvasFrame)
+ NS_QUERYFRAME_ENTRY(nsCanvasFrame)
+ NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+void
+nsCanvasFrame::ShowCustomContentContainer()
+{
+ if (mCustomContentContainer) {
+ mCustomContentContainer->UnsetAttr(kNameSpaceID_None, nsGkAtoms::hidden, true);
+ }
+}
+
+void
+nsCanvasFrame::HideCustomContentContainer()
+{
+ if (mCustomContentContainer) {
+ mCustomContentContainer->SetAttr(kNameSpaceID_None, nsGkAtoms::hidden,
+ NS_LITERAL_STRING("true"),
+ true);
+ }
+}
+
+nsresult
+nsCanvasFrame::CreateAnonymousContent(nsTArray<ContentInfo>& aElements)
+{
+ if (!mContent) {
+ return NS_OK;
+ }
+
+ nsCOMPtr<nsIDocument> doc = mContent->OwnerDoc();
+ nsresult rv = NS_OK;
+
+ // 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.
+ mCustomContentContainer->SetProperty(nsGkAtoms::restylableAnonymousNode,
+ reinterpret_cast<void*>(true));
+#endif // DEBUG
+
+ aElements.AppendElement(mCustomContentContainer);
+
+ // XXX add :moz-native-anonymous or will that be automatically set?
+ rv = mCustomContentContainer->SetAttr(kNameSpaceID_None, nsGkAtoms::_class,
+ NS_LITERAL_STRING("moz-custom-content-container"),
+ true);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Append all existing AnonymousContent nodes stored at document level if any.
+ size_t len = doc->GetAnonymousContents().Length();
+ for (size_t i = 0; i < len; ++i) {
+ nsCOMPtr<Element> node = doc->GetAnonymousContents()[i]->GetContentNode();
+ mCustomContentContainer->AppendChildTo(node->AsContent(), true);
+ }
+
+ // Only create a frame for mCustomContentContainer if it has some children.
+ if (len == 0) {
+ HideCustomContentContainer();
+ }
+
+ RefPtr<AccessibleCaretEventHub> eventHub =
+ PresContext()->GetPresShell()->GetAccessibleCaretEventHub();
+ if (eventHub) {
+ // AccessibleCaret will insert anonymous caret elements.
+ eventHub->Init();
+ }
+
+ return NS_OK;
+}
+
+void
+nsCanvasFrame::AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements, uint32_t aFilter)
+{
+ aElements.AppendElement(mCustomContentContainer);
+}
+
+void
+nsCanvasFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+ nsIScrollableFrame* sf =
+ PresContext()->GetPresShell()->GetRootScrollFrameAsScrollable();
+ if (sf) {
+ sf->RemoveScrollPositionListener(this);
+ }
+
+ // Elements inserted in the custom content container have the same lifetime as
+ // the document, so before destroying the container, make sure to keep a clone
+ // of each of them at document level so they can be re-appended on reframe.
+ if (mCustomContentContainer) {
+ nsCOMPtr<nsIDocument> doc = mContent->OwnerDoc();
+ ErrorResult rv;
+
+ nsTArray<RefPtr<mozilla::dom::AnonymousContent>>& docAnonContents =
+ doc->GetAnonymousContents();
+ for (size_t i = 0, len = docAnonContents.Length(); i < len; ++i) {
+ AnonymousContent* content = docAnonContents[i];
+ nsCOMPtr<nsINode> clonedElement = content->GetContentNode()->CloneNode(true, rv);
+ content->SetContentNode(clonedElement->AsElement());
+ }
+ }
+ nsContentUtils::DestroyAnonymousContent(&mCustomContentContainer);
+
+ nsContainerFrame::DestroyFrom(aDestructRoot);
+}
+
+void
+nsCanvasFrame::ScrollPositionWillChange(nscoord aX, nscoord aY)
+{
+ if (mDoPaintFocus) {
+ mDoPaintFocus = false;
+ PresContext()->FrameManager()->GetRootFrame()->InvalidateFrameSubtree();
+ }
+}
+
+NS_IMETHODIMP
+nsCanvasFrame::SetHasFocus(bool aHasFocus)
+{
+ if (mDoPaintFocus != aHasFocus) {
+ mDoPaintFocus = aHasFocus;
+ PresContext()->FrameManager()->GetRootFrame()->InvalidateFrameSubtree();
+
+ if (!mAddedScrollPositionListener) {
+ nsIScrollableFrame* sf =
+ PresContext()->GetPresShell()->GetRootScrollFrameAsScrollable();
+ if (sf) {
+ sf->AddScrollPositionListener(this);
+ mAddedScrollPositionListener = true;
+ }
+ }
+ }
+ return NS_OK;
+}
+
+#ifdef DEBUG
+void
+nsCanvasFrame::SetInitialChildList(ChildListID aListID,
+ nsFrameList& aChildList)
+{
+ NS_ASSERTION(aListID != kPrincipalList ||
+ aChildList.IsEmpty() || aChildList.OnlyChild(),
+ "Primary child list can have at most one frame in it");
+ nsContainerFrame::SetInitialChildList(aListID, aChildList);
+}
+
+void
+nsCanvasFrame::AppendFrames(ChildListID aListID,
+ nsFrameList& aFrameList)
+{
+ MOZ_ASSERT(aListID == kPrincipalList, "unexpected child list");
+ if (!mFrames.IsEmpty()) {
+ for (nsFrameList::Enumerator e(aFrameList); !e.AtEnd(); e.Next()) {
+ // We only allow native anonymous child frames to be in principal child
+ // list in canvas frame.
+ MOZ_ASSERT(e.get()->GetContent()->IsInNativeAnonymousSubtree(),
+ "invalid child list");
+ }
+ }
+ nsFrame::VerifyDirtyBitSet(aFrameList);
+ nsContainerFrame::AppendFrames(aListID, aFrameList);
+}
+
+void
+nsCanvasFrame::InsertFrames(ChildListID aListID,
+ nsIFrame* aPrevFrame,
+ 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, aFrameList);
+}
+
+void
+nsCanvasFrame::RemoveFrame(ChildListID aListID,
+ nsIFrame* aOldFrame)
+{
+ MOZ_ASSERT(aListID == kPrincipalList, "unexpected child list");
+ nsContainerFrame::RemoveFrame(aListID, aOldFrame);
+}
+#endif
+
+nsRect nsCanvasFrame::CanvasArea() const
+{
+ // Not clear which overflow rect we want here, but it probably doesn't
+ // matter.
+ nsRect result(GetVisualOverflowRect());
+
+ nsIScrollableFrame *scrollableFrame = do_QueryFrame(GetParent());
+ if (scrollableFrame) {
+ nsRect portRect = scrollableFrame->GetScrollPortRect();
+ result.UnionRect(result, nsRect(nsPoint(0, 0), portRect.Size()));
+ }
+ return result;
+}
+
+void
+nsDisplayCanvasBackgroundColor::Paint(nsDisplayListBuilder* aBuilder,
+ nsRenderingContext* 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)));
+ }
+}
+
+#ifdef MOZ_DUMP_PAINTING
+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) << ")";
+}
+#endif
+
+#ifndef MOZ_GFX_OPTIMIZE_MOBILE
+static void BlitSurface(DrawTarget* aDest, const gfxRect& aRect, DrawTarget* aSource)
+{
+ RefPtr<SourceSurface> source = aSource->Snapshot();
+ aDest->DrawSurface(source,
+ Rect(aRect.x, aRect.y, aRect.width, aRect.height),
+ Rect(0, 0, aRect.width, aRect.height));
+}
+#endif
+
+void
+nsDisplayCanvasBackgroundImage::Paint(nsDisplayListBuilder* aBuilder,
+ nsRenderingContext* aCtx)
+{
+ nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
+ nsPoint offset = ToReferenceFrame();
+ nsRect bgClipRect = frame->CanvasArea() + offset;
+
+#ifndef MOZ_GFX_OPTIMIZE_MOBILE
+ RefPtr<gfxContext> dest = aCtx->ThebesContext();
+ gfxRect destRect;
+ if (IsSingleFixedPositionImage(aBuilder, bgClipRect, &destRect) &&
+ aBuilder->IsPaintingToWindow() && !aBuilder->IsCompositingCheap() &&
+ !dest->CurrentMatrix().HasNonIntegerTranslation()) {
+ // Snap image rectangle to nearest pixel boundaries. This is the right way
+ // to snap for this context, because we checked HasNonIntegerTranslation
+ // above.
+ destRect.Round();
+ RefPtr<DrawTarget> dt =
+ Frame()->Properties().Get(nsIFrame::CachedBackgroundImageDT());
+ DrawTarget* destDT = dest->GetDrawTarget();
+ if (dt) {
+ BlitSurface(destDT, destRect, dt);
+ return;
+ }
+
+ dt = destDT->CreateSimilarDrawTarget(IntSize::Ceil(destRect.width,
+ destRect.height),
+ SurfaceFormat::B8G8R8A8);
+ if (dt && dt->IsValid()) {
+ RefPtr<gfxContext> ctx = gfxContext::CreateOrNull(dt);
+ MOZ_ASSERT(ctx); // already checked draw target above
+ ctx->SetMatrix(ctx->CurrentMatrix().Translate(-destRect.x, -destRect.y));
+ nsRenderingContext context(ctx);
+ PaintInternal(aBuilder, &context, bgClipRect, &bgClipRect);
+ BlitSurface(dest->GetDrawTarget(), destRect, dt);
+ frame->Properties().Set(nsIFrame::CachedBackgroundImageDT(),
+ dt.forget().take());
+ return;
+ }
+ }
+#endif
+ PaintInternal(aBuilder, aCtx, mVisibleRect, &bgClipRect);
+}
+
+bool
+nsDisplayCanvasBackgroundImage::IsSingleFixedPositionImage(nsDisplayListBuilder* aBuilder,
+ const nsRect& aClipRect,
+ gfxRect* aDestRect)
+{
+ if (!mBackgroundStyle)
+ return false;
+
+ if (mBackgroundStyle->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 = mBackgroundStyle->mImage.mLayers[mLayer];
+
+ if (layer.mAttachment != NS_STYLE_IMAGELAYER_ATTACHMENT_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,
+ nsRenderingContext* aCtx)
+{
+ nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
+ nsPoint offset = ToReferenceFrame();
+ nsRect bgClipRect = frame->CanvasArea() + offset;
+
+ PaintInternal(aBuilder, aCtx, mVisibleRect, &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 nsDisplayItem {
+public:
+ nsDisplayCanvasFocus(nsDisplayListBuilder* aBuilder, nsCanvasFrame *aFrame)
+ : nsDisplayItem(aBuilder, aFrame)
+ {
+ MOZ_COUNT_CTOR(nsDisplayCanvasFocus);
+ }
+ virtual ~nsDisplayCanvasFocus() {
+ MOZ_COUNT_DTOR(nsDisplayCanvasFocus);
+ }
+
+ virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
+ bool* aSnap) 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,
+ nsRenderingContext* aCtx) override
+ {
+ nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
+ frame->PaintFocus(aCtx->GetDrawTarget(), ToReferenceFrame());
+ }
+
+ NS_DISPLAY_DECL_NAME("CanvasFocus", TYPE_CANVAS_FOCUS)
+};
+
+void
+nsCanvasFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+ const nsRect& aDirtyRect,
+ const nsDisplayListSet& aLists)
+{
+ if (GetPrevInFlow()) {
+ DisplayOverflowContainers(aBuilder, aDirtyRect, 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 nsFrame::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(aBuilder)) {
+ nsStyleContext* bgSC;
+ const nsStyleBackground* bg = nullptr;
+ bool isThemed = IsThemed();
+ if (!isThemed && nsCSSRendering::FindBackground(this, &bgSC)) {
+ bg = bgSC->StyleBackground();
+ }
+ aLists.BorderBackground()->AppendNewToTop(
+ new (aBuilder) nsDisplayCanvasBackgroundColor(aBuilder, this));
+
+ if (isThemed) {
+ aLists.BorderBackground()->AppendNewToTop(
+ new (aBuilder) nsDisplayCanvasThemedBackground(aBuilder, this));
+ return;
+ }
+
+ if (!bg) {
+ return;
+ }
+
+ const DisplayItemScrollClip* scrollClip =
+ aBuilder->ClipState().GetCurrentInnermostScrollClip();
+
+ bool needBlendContainer = false;
+
+ // Create separate items for each background layer.
+ const nsStyleImageLayers& layers = bg->mImage;
+ NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT(i, layers) {
+ if (layers.mLayers[i].mImage.IsEmpty()) {
+ continue;
+ }
+ if (layers.mLayers[i].mBlendMode != NS_STYLE_BLEND_NORMAL) {
+ needBlendContainer = true;
+ }
+
+ nsDisplayList thisItemList;
+ nsDisplayCanvasBackgroundImage* bgItem =
+ new (aBuilder) nsDisplayCanvasBackgroundImage(aBuilder, this, i, bg);
+ if (bgItem->ShouldFixToViewport(aBuilder)) {
+ thisItemList.AppendNewToTop(
+ nsDisplayFixedPosition::CreateForFixedBackground(aBuilder, this, bgItem, i));
+ } else {
+ thisItemList.AppendNewToTop(bgItem);
+ }
+
+ if (layers.mLayers[i].mBlendMode != NS_STYLE_BLEND_NORMAL) {
+ thisItemList.AppendNewToTop(
+ new (aBuilder) nsDisplayBlendMode(aBuilder, this, &thisItemList,
+ layers.mLayers[i].mBlendMode,
+ scrollClip, i + 1));
+ }
+ aLists.BorderBackground()->AppendToTop(&thisItemList);
+ }
+
+ if (needBlendContainer) {
+ aLists.BorderBackground()->AppendNewToTop(
+ nsDisplayBlendContainer::CreateForBackgroundBlendMode(aBuilder, this,
+ aLists.BorderBackground(),
+ scrollClip));
+ }
+ }
+
+ for (nsIFrame* kid : PrincipalChildList()) {
+ // Put our child into its own pseudo-stack.
+ BuildDisplayListForChild(aBuilder, kid, aDirtyRect, aLists);
+ }
+
+#ifdef DEBUG_CANVAS_FOCUS
+ nsCOMPtr<nsIContent> focusContent;
+ aPresContext->EventStateManager()->
+ GetFocusedContent(getter_AddRefs(focusContent));
+
+ bool hasFocus = false;
+ nsCOMPtr<nsISupports> container;
+ aPresContext->GetContainer(getter_AddRefs(container));
+ nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(container));
+ if (docShell) {
+ docShell->GetHasFocus(&hasFocus);
+ printf("%p - nsCanvasFrame::Paint R:%d,%d,%d,%d DR: %d,%d,%d,%d\n", this,
+ mRect.x, mRect.y, mRect.width, mRect.height,
+ aDirtyRect.x, aDirtyRect.y, aDirtyRect.width, aDirtyRect.height);
+ }
+ printf("%p - Focus: %s c: %p DoPaint:%s\n", docShell.get(), hasFocus?"Y":"N",
+ focusContent.get(), mDoPaintFocus?"Y":"N");
+#endif
+
+ if (!mDoPaintFocus)
+ return;
+ // Only paint the focus if we're visible
+ if (!StyleVisibility()->IsVisible())
+ return;
+
+ aLists.Outlines()->AppendNewToTop(new (aBuilder)
+ 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;
+ focusRect.MoveBy(scrollableFrame->GetScrollPosition());
+ }
+
+ // XXX use the root frame foreground color, but should we find BODY frame
+ // for HTML documents?
+ nsIFrame* root = mFrames.FirstChild();
+ const nsStyleColor* color = root ? root->StyleColor() : StyleColor();
+ if (!color) {
+ NS_ERROR("current color cannot be found");
+ return;
+ }
+
+ nsCSSRendering::PaintFocus(PresContext(), aDrawTarget,
+ focusRect, color->mColor);
+}
+
+/* virtual */ nscoord
+nsCanvasFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+{
+ nscoord result;
+ DISPLAY_MIN_WIDTH(this, result);
+ if (mFrames.IsEmpty())
+ result = 0;
+ else
+ result = mFrames.FirstChild()->GetMinISize(aRenderingContext);
+ return result;
+}
+
+/* virtual */ nscoord
+nsCanvasFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+{
+ nscoord result;
+ DISPLAY_PREF_WIDTH(this, result);
+ if (mFrames.IsEmpty())
+ result = 0;
+ else
+ result = mFrames.FirstChild()->GetPrefISize(aRenderingContext);
+ return result;
+}
+
+void
+nsCanvasFrame::Reflow(nsPresContext* aPresContext,
+ ReflowOutput& aDesiredSize,
+ const ReflowInput& aReflowInput,
+ nsReflowStatus& aStatus)
+{
+ MarkInReflow();
+ DO_GLOBAL_REFLOW_COUNT("nsCanvasFrame");
+ DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
+ NS_FRAME_TRACE_REFLOW_IN("nsCanvasFrame::Reflow");
+
+ // Initialize OUT parameter
+ aStatus = NS_FRAME_COMPLETE;
+
+ nsCanvasFrame* prevCanvasFrame = static_cast<nsCanvasFrame*>
+ (GetPrevInFlow());
+ if (prevCanvasFrame) {
+ AutoFrameListPtr overflow(aPresContext,
+ prevCanvasFrame->StealOverflowFrames());
+ if (overflow) {
+ NS_ASSERTION(overflow->OnlyChild(),
+ "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, *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.
+ SetSize(nsSize(aReflowInput.ComputedWidth(), aReflowInput.ComputedHeight()));
+
+ // Reflow our one and only normal child frame. It's either the root
+ // element's frame or a placeholder for that frame, if the root element
+ // is abs-pos or fixed-pos. We may have additional children which
+ // are placeholders for continuations of fixed-pos content, but those
+ // don't need to be reflowed. The normal child is always comes before
+ // the fixed-pos placeholders, because we insert it at the start
+ // of the child list, above.
+ ReflowOutput kidDesiredSize(aReflowInput);
+ if (mFrames.IsEmpty()) {
+ // We have no child frame, so return an empty size
+ aDesiredSize.Width() = aDesiredSize.Height() = 0;
+ } else {
+ nsIFrame* kidFrame = mFrames.FirstChild();
+ bool kidDirty = (kidFrame->GetStateBits() & NS_FRAME_IS_DIRTY) != 0;
+
+ ReflowInput
+ kidReflowInput(aPresContext, aReflowInput, kidFrame,
+ aReflowInput.AvailableSize(kidFrame->GetWritingMode()));
+
+ if (aReflowInput.IsBResizeForWM(kidReflowInput.GetWritingMode()) &&
+ (kidFrame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_BSIZE)) {
+ // Tell our kid it's being block-dir resized too. Bit of a
+ // hack for framesets.
+ kidReflowInput.SetBResize(true);
+ }
+
+ WritingMode wm = aReflowInput.GetWritingMode();
+ WritingMode kidWM = kidReflowInput.GetWritingMode();
+ nsSize containerSize = aReflowInput.ComputedPhysicalSize();
+
+ LogicalMargin margin = kidReflowInput.ComputedLogicalMargin();
+ LogicalPoint kidPt(kidWM, margin.IStart(kidWM), margin.BStart(kidWM));
+
+ kidReflowInput.ApplyRelativePositioning(&kidPt, containerSize);
+
+ // Reflow the frame
+ ReflowChild(kidFrame, aPresContext, kidDesiredSize, kidReflowInput,
+ kidWM, kidPt, containerSize, 0, aStatus);
+
+ // Complete the reflow and position and size the child frame
+ FinishReflowChild(kidFrame, aPresContext, kidDesiredSize, &kidReflowInput,
+ kidWM, kidPt, containerSize, 0);
+
+ if (!NS_FRAME_IS_FULLY_COMPLETE(aStatus)) {
+ nsIFrame* nextFrame = kidFrame->GetNextInFlow();
+ NS_ASSERTION(nextFrame || aStatus & NS_FRAME_REFLOW_NEXTINFLOW,
+ "If it's incomplete and has no nif yet, it must flag a nif reflow.");
+ if (!nextFrame) {
+ nextFrame = aPresContext->PresShell()->FrameConstructor()->
+ CreateContinuingFrame(aPresContext, 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 (NS_FRAME_OVERFLOW_IS_INCOMPLETE(aStatus)) {
+ nextFrame->AddStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER);
+ }
+ }
+
+ // 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 = PresContext()->GetPresShell()->GetRootFrame();
+ viewport->InvalidateFrame();
+ }
+
+ // Return our desired size. Normally it's what we're told, but
+ // sometimes we can be given an unconstrained height (when a window
+ // is sizing-to-content), and we should compute our desired height.
+ LogicalSize finalSize(wm);
+ finalSize.ISize(wm) = aReflowInput.ComputedISize();
+ if (aReflowInput.ComputedBSize() == NS_UNCONSTRAINEDSIZE) {
+ finalSize.BSize(wm) = kidFrame->GetLogicalSize(wm).BSize(wm) +
+ kidReflowInput.ComputedLogicalMargin().BStartEnd(wm);
+ } else {
+ finalSize.BSize(wm) = aReflowInput.ComputedBSize();
+ }
+
+ aDesiredSize.SetSize(wm, finalSize);
+ aDesiredSize.SetOverflowAreasToDesiredBounds();
+ aDesiredSize.mOverflowAreas.UnionWith(
+ kidDesiredSize.mOverflowAreas + kidFrame->GetPosition());
+ }
+
+ if (prevCanvasFrame) {
+ ReflowOverflowContainerChildren(aPresContext, aReflowInput,
+ aDesiredSize.mOverflowAreas, 0,
+ aStatus);
+ }
+
+ FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput, aStatus);
+
+ NS_FRAME_TRACE_REFLOW_OUT("nsCanvasFrame::Reflow", aStatus);
+ NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
+}
+
+nsIAtom*
+nsCanvasFrame::GetType() const
+{
+ return nsGkAtoms::canvasFrame;
+}
+
+nsresult
+nsCanvasFrame::GetContentForEvent(WidgetEvent* aEvent,
+ nsIContent** aContent)
+{
+ NS_ENSURE_ARG_POINTER(aContent);
+ nsresult rv = nsFrame::GetContentForEvent(aEvent,
+ aContent);
+ if (NS_FAILED(rv) || !*aContent) {
+ nsIFrame* kid = mFrames.FirstChild();
+ if (kid) {
+ rv = kid->GetContentForEvent(aEvent,
+ aContent);
+ }
+ }
+
+ return rv;
+}
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult
+nsCanvasFrame::GetFrameName(nsAString& aResult) const
+{
+ return MakeFrameName(NS_LITERAL_STRING("Canvas"), aResult);
+}
+#endif