Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 980 insertions, 0 deletions

diff --git a/layout/generic/nsPageFrame.cpp b/layout/generic/nsPageFrame.cpp
new file mode 100644
index 0000000000..fb9cfa2e81
--- /dev/null
+++ b/layout/generic/nsPageFrame.cpp
@@ -0,0 +1,980 @@
+/* -*- 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 "nsPageFrame.h"
+
+#include "mozilla/AppUnits.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/intl/Segmenter.h"
+#include "gfxContext.h"
+#include "nsDeviceContext.h"
+#include "nsFontMetrics.h"
+#include "nsIFrame.h"
+#include "nsLayoutUtils.h"
+#include "nsPresContext.h"
+#include "nsGkAtoms.h"
+#include "nsFieldSetFrame.h"
+#include "nsPageContentFrame.h"
+#include "nsDisplayList.h"
+#include "nsPageSequenceFrame.h"  // for nsSharedPageData
+#include "nsTextFormatter.h"      // for page number localization formatting
+#include "nsBidiUtils.h"
+#include "nsIPrintSettings.h"
+#include "PrintedSheetFrame.h"
+
+#include "mozilla/Logging.h"
+extern mozilla::LazyLogModule gLayoutPrintingLog;
+#define PR_PL(_p1) MOZ_LOG(gLayoutPrintingLog, mozilla::LogLevel::Debug, _p1)
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+
+nsPageFrame* NS_NewPageFrame(PresShell* aPresShell, ComputedStyle* aStyle) {
+  return new (aPresShell) nsPageFrame(aStyle, aPresShell->GetPresContext());
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsPageFrame)
+
+NS_QUERYFRAME_HEAD(nsPageFrame)
+  NS_QUERYFRAME_ENTRY(nsPageFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+nsPageFrame::nsPageFrame(ComputedStyle* aStyle, nsPresContext* aPresContext)
+    : nsContainerFrame(aStyle, aPresContext, kClassID) {}
+
+nsPageFrame::~nsPageFrame() = default;
+
+nsReflowStatus nsPageFrame::ReflowPageContent(
+    nsPresContext* aPresContext, const ReflowInput& aPageReflowInput) {
+  nsPageContentFrame* const frame = PageContentFrame();
+  // If this is the first page, it won't have its page name and computed style
+  // set yet. Before reflow, make sure that page name and computed style have
+  // been applied.
+  frame->EnsurePageName();
+  // XXX Pay attention to the page's border and padding...
+  //
+  // Reflow our ::-moz-page-content frame, allowing it only to be as big as we
+  // are (minus margins).
+  const nsSize pageSize = ComputePageSize();
+  // Scaling applied to the page in the single page-per-sheet case (used for
+  // down-scaling when the page is too large to fit on the sheet we are printing
+  // on). In the single page-per-sheet case, we need this here to preemptively
+  // increase the margins by the same amount that the scaling will reduce them
+  // in order to make sure that their physical size is unchanged (particularly
+  // important for the unwriteable margins).
+  const auto* ppsInfo = GetSharedPageData()->PagesPerSheetInfo();
+  const float pageSizeScale =
+      ppsInfo->mNumPages == 1 ? ComputeSinglePPSPageSizeScale(pageSize) : 1.0f;
+  // Scaling applied to content, as given by the print UI.
+  // This is an additional scale factor that is applied to the content in the
+  // nsPageContentFrame.
+  const float extraContentScale = aPresContext->GetPageScale();
+  // Size for the page content. This will be scaled by extraContentScale, and
+  // is used to calculate the computed size of the nsPageContentFrame content
+  // by subtracting margins.
+  nsSize availableSpace = pageSize;
+
+  // When the reflow size is NS_UNCONSTRAINEDSIZE it means we are reflowing
+  // a single page to print selection. So this means we want to use
+  // NS_UNCONSTRAINEDSIZE without altering it.
+  //
+  // FIXME(emilio): Is this still true?
+  availableSpace.width =
+      NSToCoordCeil(availableSpace.width / extraContentScale);
+  if (availableSpace.height != NS_UNCONSTRAINEDSIZE) {
+    availableSpace.height =
+        NSToCoordCeil(availableSpace.height / extraContentScale);
+  }
+
+  // Get the number of Twips per pixel from the PresContext
+  const nscoord onePixel = AppUnitsPerCSSPixel();
+
+  // insurance against infinite reflow, when reflowing less than a pixel
+  // XXX Shouldn't we do something more friendly when invalid margins
+  //     are set?
+  if (availableSpace.width < onePixel || availableSpace.height < onePixel) {
+    NS_WARNING("Reflow aborted; no space for content");
+    return {};
+  }
+
+  ReflowInput kidReflowInput(
+      aPresContext, aPageReflowInput, frame,
+      LogicalSize(frame->GetWritingMode(), availableSpace));
+  kidReflowInput.mFlags.mIsTopOfPage = true;
+  kidReflowInput.mFlags.mTableIsSplittable = true;
+
+  nsMargin defaultMargins = aPresContext->GetDefaultPageMargin();
+  // The default margins are in the coordinate space of the physical paper.
+  // Scale them by the pageSizeScale to convert them to the content coordinate
+  // space.
+  for (const auto side : mozilla::AllPhysicalSides()) {
+    defaultMargins.Side(side) =
+        NSToCoordRound((float)defaultMargins.Side(side) / pageSizeScale);
+  }
+  mPageContentMargin = defaultMargins;
+
+  // Use the margins given in the @page rule if told to do so.
+  // We clamp to the paper's unwriteable margins to avoid clipping, *except*
+  // that we will respect a margin of zero if specified, assuming this means
+  // the document is intended to fit the paper size exactly, and the client is
+  // taking full responsibility for what happens around the edges.
+  if (mPD->mPrintSettings->GetHonorPageRuleMargins()) {
+    const auto& margin = kidReflowInput.mStyleMargin->mMargin;
+    for (const auto side : mozilla::AllPhysicalSides()) {
+      if (!margin.Get(side).IsAuto()) {
+        // Computed margins are already in the coordinate space of the content,
+        // do not scale.
+        const nscoord computed =
+            kidReflowInput.ComputedPhysicalMargin().Side(side);
+        // Respecting a zero margin is particularly important when the client
+        // is PDF.js where the PDF already contains the margins.
+        // User could also be asking to ignore unwriteable margins (Though
+        // currently, it is impossible through the print UI to set both
+        // `HonorPageRuleMargins` and `IgnoreUnwriteableMargins`).
+        if (computed == 0 ||
+            mPD->mPrintSettings->GetIgnoreUnwriteableMargins()) {
+          mPageContentMargin.Side(side) = computed;
+        } else {
+          // Unwriteable margins are in the coordinate space of the physical
+          // paper. Scale them by the pageSizeScale to convert them to the
+          // content coordinate space.
+          const int32_t unwriteableTwips =
+              mPD->mPrintSettings->GetUnwriteableMarginInTwips().Side(side);
+          const nscoord unwriteable = nsPresContext::CSSTwipsToAppUnits(
+              (float)unwriteableTwips / pageSizeScale);
+          mPageContentMargin.Side(side) = std::max(
+              kidReflowInput.ComputedPhysicalMargin().Side(side), unwriteable);
+        }
+      }
+    }
+  }
+
+  // TODO: This seems odd that we need to scale the margins by the extra
+  // scale factor, but this is needed for correct margins.
+  // Why are the margins already scaled? Shouldn't they be stored so that this
+  // scaling factor would be redundant?
+  nscoord computedWidth =
+      availableSpace.width - mPageContentMargin.LeftRight() / extraContentScale;
+  nscoord computedHeight;
+  if (availableSpace.height == NS_UNCONSTRAINEDSIZE) {
+    computedHeight = NS_UNCONSTRAINEDSIZE;
+  } else {
+    computedHeight = availableSpace.height -
+                     mPageContentMargin.TopBottom() / extraContentScale;
+  }
+
+  // Check the width and height, if they're too small we reset the margins
+  // back to the default.
+  if (computedWidth < onePixel || computedHeight < onePixel) {
+    mPageContentMargin = defaultMargins;
+    computedWidth = availableSpace.width -
+                    mPageContentMargin.LeftRight() / extraContentScale;
+    if (computedHeight != NS_UNCONSTRAINEDSIZE) {
+      computedHeight = availableSpace.height -
+                       mPageContentMargin.TopBottom() / extraContentScale;
+    }
+    // And if they're still too small, we give up.
+    if (computedWidth < onePixel || computedHeight < onePixel) {
+      NS_WARNING("Reflow aborted; no space for content");
+      return {};
+    }
+  }
+
+  kidReflowInput.SetComputedWidth(computedWidth);
+  kidReflowInput.SetComputedHeight(computedHeight);
+
+  // calc location of frame
+  const nscoord xc = mPageContentMargin.left;
+  const nscoord yc = mPageContentMargin.top;
+
+  // Get the child's desired size
+  ReflowOutput kidOutput(kidReflowInput);
+  nsReflowStatus kidStatus;
+  ReflowChild(frame, aPresContext, kidOutput, kidReflowInput, xc, yc,
+              ReflowChildFlags::Default, kidStatus);
+
+  // Place and size the child
+  FinishReflowChild(frame, aPresContext, kidOutput, &kidReflowInput, xc, yc,
+                    ReflowChildFlags::Default);
+
+  NS_ASSERTION(!kidStatus.IsFullyComplete() || !frame->GetNextInFlow(),
+               "bad child flow list");
+  return kidStatus;
+}
+
+void nsPageFrame::Reflow(nsPresContext* aPresContext,
+                         ReflowOutput& aReflowOutput,
+                         const ReflowInput& aReflowInput,
+                         nsReflowStatus& aStatus) {
+  MarkInReflow();
+  DO_GLOBAL_REFLOW_COUNT("nsPageFrame");
+  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aReflowOutput, aStatus);
+  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+  MOZ_ASSERT(mPD, "Need a pointer to nsSharedPageData before reflow starts");
+
+  // Our status is the same as our child's.
+  aStatus = ReflowPageContent(aPresContext, aReflowInput);
+
+  PR_PL(("PageFrame::Reflow %p ", this));
+  PR_PL(("[%d,%d][%d,%d]\n", aReflowOutput.Width(), aReflowOutput.Height(),
+         aReflowInput.AvailableWidth(), aReflowInput.AvailableHeight()));
+
+  // Return our desired size
+  WritingMode wm = aReflowInput.GetWritingMode();
+  aReflowOutput.ISize(wm) = aReflowInput.AvailableISize();
+  if (aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE) {
+    aReflowOutput.BSize(wm) = aReflowInput.AvailableBSize();
+  }
+
+  aReflowOutput.SetOverflowAreasToDesiredBounds();
+  FinishAndStoreOverflow(&aReflowOutput);
+
+  PR_PL(("PageFrame::Reflow %p ", this));
+  PR_PL(("[%d,%d]\n", aReflowInput.AvailableWidth(),
+         aReflowInput.AvailableHeight()));
+}
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult nsPageFrame::GetFrameName(nsAString& aResult) const {
+  return MakeFrameName(u"Page"_ns, aResult);
+}
+#endif
+
+void nsPageFrame::ProcessSpecialCodes(const nsString& aStr, nsString& aNewStr) {
+  aNewStr = aStr;
+
+  // Search to see if the &D code is in the string
+  // then subst in the current date/time
+  constexpr auto kDate = u"&D"_ns;
+  if (aStr.Find(kDate) != kNotFound) {
+    aNewStr.ReplaceSubstring(kDate, mPD->mDateTimeStr);
+  }
+
+  // NOTE: Must search for &PT before searching for &P
+  //
+  // Search to see if the "page number and page" total code are in the string
+  // and replace the page number and page total code with the actual
+  // values
+  constexpr auto kPageAndTotal = u"&PT"_ns;
+  if (aStr.Find(kPageAndTotal) != kNotFound) {
+    nsAutoString uStr;
+    nsTextFormatter::ssprintf(uStr, mPD->mPageNumAndTotalsFormat.get(),
+                              mPageNum, mPD->mRawNumPages);
+    aNewStr.ReplaceSubstring(kPageAndTotal, uStr);
+  }
+
+  // Search to see if the page number code is in the string
+  // and replace the page number code with the actual value
+  constexpr auto kPage = u"&P"_ns;
+  if (aStr.Find(kPage) != kNotFound) {
+    nsAutoString uStr;
+    nsTextFormatter::ssprintf(uStr, mPD->mPageNumFormat.get(), mPageNum);
+    aNewStr.ReplaceSubstring(kPage, uStr);
+  }
+
+  constexpr auto kTitle = u"&T"_ns;
+  if (aStr.Find(kTitle) != kNotFound) {
+    aNewStr.ReplaceSubstring(kTitle, mPD->mDocTitle);
+  }
+
+  constexpr auto kDocURL = u"&U"_ns;
+  if (aStr.Find(kDocURL) != kNotFound) {
+    aNewStr.ReplaceSubstring(kDocURL, mPD->mDocURL);
+  }
+
+  constexpr auto kPageTotal = u"&L"_ns;
+  if (aStr.Find(kPageTotal) != kNotFound) {
+    nsAutoString uStr;
+    nsTextFormatter::ssprintf(uStr, mPD->mPageNumFormat.get(),
+                              mPD->mRawNumPages);
+    aNewStr.ReplaceSubstring(kPageTotal, uStr);
+  }
+}
+
+//------------------------------------------------------------------------------
+nscoord nsPageFrame::GetXPosition(gfxContext& aRenderingContext,
+                                  nsFontMetrics& aFontMetrics,
+                                  const nsRect& aRect, int32_t aJust,
+                                  const nsString& aStr) {
+  nscoord width = nsLayoutUtils::AppUnitWidthOfStringBidi(
+      aStr, this, aFontMetrics, aRenderingContext);
+  nscoord x = aRect.x;
+  switch (aJust) {
+    case nsIPrintSettings::kJustLeft:
+      x += mPD->mEdgePaperMargin.left;
+      break;
+
+    case nsIPrintSettings::kJustCenter:
+      x += (aRect.width - width) / 2;
+      break;
+
+    case nsIPrintSettings::kJustRight:
+      x += aRect.width - width - mPD->mEdgePaperMargin.right;
+      break;
+  }  // switch
+
+  return x;
+}
+
+// Draw a header or footer
+// @param aRenderingContext - rendering content to draw into
+// @param aHeaderFooter - indicates whether it is a header or footer
+// @param aStrLeft - string for the left header or footer; can be empty
+// @param aStrCenter - string for the center header or footer; can be empty
+// @param aStrRight - string for the right header or footer; can be empty
+// @param aRect - the rect of the page
+// @param aAscent - the ascent of the font
+// @param aHeight - the height of the font
+void nsPageFrame::DrawHeaderFooter(
+    gfxContext& aRenderingContext, nsFontMetrics& aFontMetrics,
+    nsHeaderFooterEnum aHeaderFooter, const nsString& aStrLeft,
+    const nsString& aStrCenter, const nsString& aStrRight, const nsRect& aRect,
+    nscoord aAscent, nscoord aHeight) {
+  int32_t numStrs = 0;
+  if (!aStrLeft.IsEmpty()) numStrs++;
+  if (!aStrCenter.IsEmpty()) numStrs++;
+  if (!aStrRight.IsEmpty()) numStrs++;
+
+  if (numStrs == 0) return;
+  const nscoord contentWidth =
+      aRect.width - (mPD->mEdgePaperMargin.left + mPD->mEdgePaperMargin.right);
+  const nscoord strSpace = contentWidth / numStrs;
+
+  if (!aStrLeft.IsEmpty()) {
+    DrawHeaderFooter(aRenderingContext, aFontMetrics, aHeaderFooter,
+                     nsIPrintSettings::kJustLeft, aStrLeft, aRect, aAscent,
+                     aHeight, strSpace);
+  }
+  if (!aStrCenter.IsEmpty()) {
+    DrawHeaderFooter(aRenderingContext, aFontMetrics, aHeaderFooter,
+                     nsIPrintSettings::kJustCenter, aStrCenter, aRect, aAscent,
+                     aHeight, strSpace);
+  }
+  if (!aStrRight.IsEmpty()) {
+    DrawHeaderFooter(aRenderingContext, aFontMetrics, aHeaderFooter,
+                     nsIPrintSettings::kJustRight, aStrRight, aRect, aAscent,
+                     aHeight, strSpace);
+  }
+}
+
+// Draw a header or footer string
+// @param aRenderingContext - rendering context to draw into
+// @param aHeaderFooter - indicates whether it is a header or footer
+// @param aJust - indicates where the string is located within the header/footer
+// @param aStr - the string to be drawn
+// @param aRect - the rect of the page
+// @param aHeight - the height of the font
+// @param aAscent - the ascent of the font
+// @param aWidth - available width for the string
+void nsPageFrame::DrawHeaderFooter(gfxContext& aRenderingContext,
+                                   nsFontMetrics& aFontMetrics,
+                                   nsHeaderFooterEnum aHeaderFooter,
+                                   int32_t aJust, const nsString& aStr,
+                                   const nsRect& aRect, nscoord aAscent,
+                                   nscoord aHeight, nscoord aWidth) {
+  DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
+
+  if ((aHeaderFooter == eHeader && aHeight < mPageContentMargin.top) ||
+      (aHeaderFooter == eFooter && aHeight < mPageContentMargin.bottom)) {
+    nsAutoString str;
+    ProcessSpecialCodes(aStr, str);
+
+    int32_t len = (int32_t)str.Length();
+    if (len == 0) {
+      return;  // bail is empty string
+    }
+
+    int32_t index;
+    int32_t textWidth = 0;
+    const char16_t* text = str.get();
+    // find how much text fits, the "position" is the size of the available area
+    if (nsLayoutUtils::BinarySearchForPosition(drawTarget, aFontMetrics, text,
+                                               0, 0, 0, len, int32_t(aWidth),
+                                               index, textWidth)) {
+      if (index < len - 1) {
+        // we can't fit in all the text, try to remove 3 glyphs and append
+        // three "." charactrers.
+
+        // TODO: This might not actually remove three glyphs in cases where
+        // ZWJ sequences, regional indicators, etc are used.
+        // We also have guarantee that removing three glyphs will make enough
+        // space for the ellipse, if they are zero-width or even just narrower
+        // than the "." character.
+        // See https://bugzilla.mozilla.org/1765008
+        mozilla::intl::GraphemeClusterBreakReverseIteratorUtf16 revIter(str);
+
+        // Start iteration at the point where the text does properly fit.
+        revIter.Seek(index);
+
+        // Step backwards 3 times, checking if we have any string left by the
+        // end.
+        revIter.Next();
+        revIter.Next();
+        if (const Maybe<uint32_t> maybeIndex = revIter.Next()) {
+          // TODO: We should consider checking for the ellipse character, or
+          // possibly for another continuation indicator based on
+          // localization.
+          // See https://bugzilla.mozilla.org/1765007
+          str.Truncate(*maybeIndex);
+          str.AppendLiteral("...");
+        } else {
+          // We can only fit 3 or fewer chars.  Just show nothing
+          str.Truncate();
+        }
+      }
+    } else {
+      return;  // bail if couldn't find the correct length
+    }
+
+    if (HasRTLChars(str)) {
+      PresContext()->SetBidiEnabled();
+    }
+
+    // calc the x and y positions of the text
+    nscoord x =
+        GetXPosition(aRenderingContext, aFontMetrics, aRect, aJust, str);
+    nscoord y;
+    if (aHeaderFooter == eHeader) {
+      y = aRect.y + mPD->mEdgePaperMargin.top;
+    } else {
+      y = aRect.YMost() - aHeight - mPD->mEdgePaperMargin.bottom;
+    }
+
+    // set up new clip and draw the text
+    aRenderingContext.Save();
+    aRenderingContext.Clip(NSRectToSnappedRect(
+        aRect, PresContext()->AppUnitsPerDevPixel(), *drawTarget));
+    aRenderingContext.SetColor(sRGBColor::OpaqueBlack());
+    nsLayoutUtils::DrawString(this, aFontMetrics, &aRenderingContext, str.get(),
+                              str.Length(), nsPoint(x, y + aAscent), nullptr,
+                              DrawStringFlags::ForceHorizontal);
+    aRenderingContext.Restore();
+  }
+}
+
+class nsDisplayHeaderFooter final : public nsPaintedDisplayItem {
+ public:
+  nsDisplayHeaderFooter(nsDisplayListBuilder* aBuilder, nsPageFrame* aFrame)
+      : nsPaintedDisplayItem(aBuilder, aFrame) {
+    MOZ_COUNT_CTOR(nsDisplayHeaderFooter);
+  }
+  MOZ_COUNTED_DTOR_OVERRIDE(nsDisplayHeaderFooter)
+
+  virtual void Paint(nsDisplayListBuilder* aBuilder,
+                     gfxContext* aCtx) override {
+#ifdef DEBUG
+    nsPageFrame* pageFrame = do_QueryFrame(mFrame);
+    MOZ_ASSERT(pageFrame, "We should have an nsPageFrame");
+#endif
+    static_cast<nsPageFrame*>(mFrame)->PaintHeaderFooter(
+        *aCtx, ToReferenceFrame(), false);
+  }
+  NS_DISPLAY_DECL_NAME("HeaderFooter", TYPE_HEADER_FOOTER)
+
+  virtual nsRect GetComponentAlphaBounds(
+      nsDisplayListBuilder* aBuilder) const override {
+    bool snap;
+    return GetBounds(aBuilder, &snap);
+  }
+};
+
+static void PaintMarginGuides(nsIFrame* aFrame, DrawTarget* aDrawTarget,
+                              const nsRect& aDirtyRect, nsPoint aPt) {
+  // Set up parameters needed to draw the guides: we draw them in blue,
+  // using 2px-long dashes with 2px separation and a line width of 0.5px.
+  // Drawing is antialiased, so on a non-hidpi screen where the line width is
+  // less than one device pixel, it doesn't disappear but renders fainter
+  // than a solid 1px-wide line would be.
+  // (In many cases, the entire preview is scaled down so that the guides
+  // will be nominally less than 1 dev px even on a hidpi screen, resulting
+  // in lighter antialiased rendering so they don't dominate the page.)
+  ColorPattern pattern(ToDeviceColor(sRGBColor(0.0f, 0.0f, 1.0f)));
+  Float dashes[] = {2.0f, 2.0f};
+  StrokeOptions stroke(/* line width (in CSS px) */ 0.5f,
+                       JoinStyle::MITER_OR_BEVEL, CapStyle::BUTT,
+                       /* mitre limit (default, not used) */ 10.0f,
+                       /* set dash pattern of 2px stroke, 2px gap */
+                       ArrayLength(dashes), dashes,
+                       /* dash offset */ 0.0f);
+  DrawOptions options;
+
+  MOZ_RELEASE_ASSERT(aFrame->IsPageFrame());
+  const nsMargin& margin =
+      static_cast<nsPageFrame*>(aFrame)->GetUsedPageContentMargin();
+  int32_t appUnitsPerDevPx = aFrame->PresContext()->AppUnitsPerDevPixel();
+
+  // Get the frame's rect and inset by the margins to get the edges of the
+  // content area, where we want to draw the guides.
+  // We draw in two stages, first applying the top/bottom margins and drawing
+  // the horizontal guides across the full width of the page.
+  nsRect rect(aPt, aFrame->GetSize());
+  rect.Deflate(nsMargin(margin.top, 0, margin.bottom, 0));
+  Rect r = NSRectToRect(rect, appUnitsPerDevPx);
+  aDrawTarget->StrokeLine(r.TopLeft(), r.TopRight(), pattern, stroke, options);
+  aDrawTarget->StrokeLine(r.BottomLeft(), r.BottomRight(), pattern, stroke,
+                          options);
+
+  // Then reset rect, apply the left/right margins, and draw vertical guides
+  // extending the full height of the page.
+  rect = nsRect(aPt, aFrame->GetSize());
+  rect.Deflate(nsMargin(0, margin.right, 0, margin.left));
+  r = NSRectToRect(rect, appUnitsPerDevPx);
+  aDrawTarget->StrokeLine(r.TopLeft(), r.BottomLeft(), pattern, stroke,
+                          options);
+  aDrawTarget->StrokeLine(r.TopRight(), r.BottomRight(), pattern, stroke,
+                          options);
+}
+
+static std::tuple<uint32_t, uint32_t> GetRowAndColFromIdx(uint32_t aIdxOnSheet,
+                                                          uint32_t aNumCols) {
+  // Compute the row index by *dividing* the item's ordinal position by how
+  // many items fit in each row (i.e. the number of columns), and flooring.
+  // Compute the column index by getting the remainder of that division:
+  // Notably, mNumRows is irrelevant to this computation; that's because
+  // we're adding new items column-by-column rather than row-by-row.
+  return {aIdxOnSheet / aNumCols, aIdxOnSheet % aNumCols};
+}
+
+// Helper for BuildDisplayList:
+static gfx::Matrix4x4 ComputePagesPerSheetAndPageSizeTransform(
+    const nsIFrame* aFrame, float aAppUnitsPerPixel) {
+  MOZ_ASSERT(aFrame->IsPageFrame());
+  auto* pageFrame = static_cast<const nsPageFrame*>(aFrame);
+  const nsSize contentPageSize = pageFrame->ComputePageSize();
+  MOZ_ASSERT(contentPageSize.width > 0 && contentPageSize.height > 0);
+  nsSharedPageData* pd = pageFrame->GetSharedPageData();
+  const auto* ppsInfo = pd->PagesPerSheetInfo();
+
+  const nsContainerFrame* const parentFrame = pageFrame->GetParent();
+  MOZ_ASSERT(parentFrame->IsPrintedSheetFrame(),
+             "Parent of nsPageFrame should be PrintedSheetFrame");
+  const auto* sheetFrame = static_cast<const PrintedSheetFrame*>(parentFrame);
+
+  const double rotation =
+      pageFrame->GetPageOrientationRotation(pageFrame->GetSharedPageData());
+
+  gfx::Matrix4x4 transform;
+
+  if (ppsInfo->mNumPages == 1) {
+    if (rotation != 0.0) {
+      const nsSize sheetSize = sheetFrame->GetSizeForChildren();
+      const bool sheetIsPortrait = sheetSize.width < sheetSize.height;
+      const bool rotatingClockwise = rotation > 0.0;
+
+      // rotation point:
+      int32_t x, y;
+      if (rotatingClockwise != sheetIsPortrait) {
+        // rotating portrait clockwise, or landscape counterclockwise
+        x = y = std::min(sheetSize.width, sheetSize.height) / 2;
+      } else {
+        // rotating portrait counterclockwise, or landscape clockwise
+        x = y = std::max(sheetSize.width, sheetSize.height) / 2;
+      }
+
+      transform = gfx::Matrix4x4::Translation(
+          NSAppUnitsToFloatPixels(x, aAppUnitsPerPixel),
+          NSAppUnitsToFloatPixels(y, aAppUnitsPerPixel), 0);
+      transform.RotateZ(rotation);
+      transform.PreTranslate(NSAppUnitsToFloatPixels(-x, aAppUnitsPerPixel),
+                             NSAppUnitsToFloatPixels(-y, aAppUnitsPerPixel), 0);
+    }
+
+    float scale = pageFrame->ComputeSinglePPSPageSizeScale(contentPageSize);
+    transform.PreScale(scale, scale, 1);
+    return transform;
+  }
+
+  // The multiple pages-per-sheet case.
+
+  // Begin with the translation of the page to its pages-per-sheet grid "cell"
+  // (the grid origin accounts for the sheet's unwriteable margins):
+  const nsPoint gridOrigin = sheetFrame->GetGridOrigin();
+  const nscoord cellWidth = sheetFrame->GetGridCellWidth();
+  const nscoord cellHeight = sheetFrame->GetGridCellHeight();
+  uint32_t rowIdx, colIdx;
+  std::tie(rowIdx, colIdx) = GetRowAndColFromIdx(pageFrame->IndexOnSheet(),
+                                                 sheetFrame->GetGridNumCols());
+  transform = gfx::Matrix4x4::Translation(
+      NSAppUnitsToFloatPixels(gridOrigin.x + nscoord(colIdx) * cellWidth,
+                              aAppUnitsPerPixel),
+      NSAppUnitsToFloatPixels(gridOrigin.y + nscoord(rowIdx) * cellHeight,
+                              aAppUnitsPerPixel),
+      0.0f);
+
+  // Scale the page to fit, centered, in the grid cell:
+  float scaleX = float(cellWidth) / float(contentPageSize.width);
+  float scaleY = float(cellHeight) / float(contentPageSize.height);
+  MOZ_ASSERT(scaleX > 0.0f && scaleX <= 1.0f && scaleY > 0.0f &&
+             scaleY <= 1.0f);
+  float scale;
+  float dx = 0.0f, dy = 0.0f;
+  if (scaleX < scaleY) {
+    scale = scaleX;
+    // We need to scale down more for the width than the height, so we'll have
+    // some spare space in the page's vertical direction. We offset the page
+    // to share that space equally above and below the page to center it.
+    nscoord extraSpace =
+        cellHeight - NSToCoordRound(float(contentPageSize.height) * scale);
+    dy = NSAppUnitsToFloatPixels(extraSpace / 2, aAppUnitsPerPixel);
+  } else {
+    scale = scaleY;
+    nscoord extraSpace =
+        cellWidth - NSToCoordRound(float(contentPageSize.width) * scale);
+    dx = NSAppUnitsToFloatPixels(extraSpace / 2, aAppUnitsPerPixel);
+  }
+  transform.PreTranslate(dx, dy, 0.0f);
+  transform.PreScale(scale, scale, 1.0f);
+
+  // Apply 'page-orientation' rotation, if applicable:
+  if (rotation != 0.0) {
+    // We've already translated and scaled the page to fit the cell, ignoring
+    // rotation. Here we rotate the page around its center and, if necessary,
+    // also scale it to fit it to its cell for its orientation change.
+
+    float fitScale = 1.0f;
+    if (MOZ_LIKELY(cellWidth != cellHeight &&
+                   contentPageSize.width != contentPageSize.height)) {
+      // If neither the cell nor the page are square, the scale must change.
+      float cellRatio = float(cellWidth) / float(cellHeight);
+      float pageRatio =
+          float(contentPageSize.width) / float(contentPageSize.height);
+      const bool orientationWillMatchAfterRotation =
+          floor(cellRatio) != floor(pageRatio);
+      if (cellRatio > 1.0f) {
+        cellRatio = 1.0f / cellRatio;  // normalize
+      }
+      if (pageRatio > 1.0f) {
+        pageRatio = 1.0f / pageRatio;  // normalize
+      }
+      fitScale = std::max(cellRatio, pageRatio);
+      if (orientationWillMatchAfterRotation) {
+        // Scale up, not down
+        fitScale = 1.0f / fitScale;
+      }
+    }
+
+    transform.PreTranslate(
+        NSAppUnitsToFloatPixels(contentPageSize.width / 2, aAppUnitsPerPixel),
+        NSAppUnitsToFloatPixels(contentPageSize.height / 2, aAppUnitsPerPixel),
+        0);
+    if (MOZ_LIKELY(fitScale != 1.0f)) {
+      transform.PreScale(fitScale, fitScale, 1.0f);
+    }
+    transform.RotateZ(rotation);
+    transform.PreTranslate(
+        NSAppUnitsToFloatPixels(-contentPageSize.width / 2, aAppUnitsPerPixel),
+        NSAppUnitsToFloatPixels(-contentPageSize.height / 2, aAppUnitsPerPixel),
+        0);
+  }
+
+  return transform;
+}
+
+nsIFrame::ComputeTransformFunction nsPageFrame::GetTransformGetter() const {
+  return ComputePagesPerSheetAndPageSizeTransform;
+}
+
+nsPageContentFrame* nsPageFrame::PageContentFrame() const {
+  nsIFrame* const frame = mFrames.FirstChild();
+  MOZ_ASSERT(frame, "pageFrame must have one child");
+  MOZ_ASSERT(frame->IsPageContentFrame(),
+             "pageFrame must have pageContentFrame as the first child");
+  return static_cast<nsPageContentFrame*>(frame);
+}
+
+nsSize nsPageFrame::ComputePageSize() const {
+  // Compute the expected page-size.
+  const nsPageFrame* const frame =
+      StaticPrefs::layout_css_allow_mixed_page_sizes()
+          ? this
+          : static_cast<nsPageFrame*>(FirstContinuation());
+  const StylePageSize& pageSize = frame->PageContentFrame()->StylePage()->mSize;
+  nsSize size = PresContext()->GetPageSize();
+  if (pageSize.IsSize()) {
+    // Use the specified size,
+    // ignoring sizes that include a zero width or height.
+    // These are also ignored in ServoStyleSet::GetPageSizeForPageName()
+    // when getting the paper size.
+    nscoord cssPageWidth = pageSize.AsSize().width.ToAppUnits();
+    nscoord cssPageHeight = pageSize.AsSize().height.ToAppUnits();
+    if (cssPageWidth > 0 && cssPageHeight > 0) {
+      return nsSize{cssPageWidth, cssPageHeight};
+    }
+    // Invalid size; just return the default
+    return size;
+  }
+
+  if (pageSize.IsOrientation()) {
+    // Ensure the correct orientation is applied.
+    if (pageSize.AsOrientation() == StylePageSizeOrientation::Portrait) {
+      if (size.width > size.height) {
+        std::swap(size.width, size.height);
+      }
+    } else {
+      MOZ_ASSERT(pageSize.AsOrientation() ==
+                 StylePageSizeOrientation::Landscape);
+      if (size.width < size.height) {
+        std::swap(size.width, size.height);
+      }
+    }
+  } else {
+    MOZ_ASSERT(pageSize.IsAuto(), "Impossible page-size value?");
+  }
+  return size;
+}
+
+float nsPageFrame::ComputeSinglePPSPageSizeScale(
+    const nsSize aContentPageSize) const {
+  MOZ_ASSERT(GetSharedPageData()->PagesPerSheetInfo()->mNumPages == 1,
+             "Only intended for the pps==1 case");
+  MOZ_ASSERT(aContentPageSize == ComputePageSize(),
+             "Incorrect content page size");
+
+  // Check for the simplest case first, an auto page-size which requires no
+  // scaling at all.
+  {
+    const nsPageFrame* const frame =
+        StaticPrefs::layout_css_allow_mixed_page_sizes()
+            ? this
+            : static_cast<nsPageFrame*>(FirstContinuation());
+    const StylePageSize& pageSize =
+        frame->PageContentFrame()->StylePage()->mSize;
+    if (pageSize.IsAuto()) {
+      return 1.0f;
+    }
+  }
+
+  const nsContainerFrame* const parent = GetParent();
+  MOZ_ASSERT(parent && parent->IsPrintedSheetFrame(),
+             "Parent of nsPageFrame should be PrintedSheetFrame");
+  const auto* sheet = static_cast<const PrintedSheetFrame*>(parent);
+
+  // Compute scaling due to a possible mismatch in the paper size we are
+  // printing to (from the pres context) and the specified page size when the
+  // content uses "@page {size: ...}" to specify a page size for the content.
+  float scale = 1.0f;
+
+  const nsSize sheetSize = sheet->GetSizeForChildren();
+  nscoord contentPageHeight = aContentPageSize.height;
+  // Scale down if the target is too wide.
+  if (aContentPageSize.width > sheetSize.width) {
+    scale *= float(sheetSize.width) / float(aContentPageSize.width);
+    contentPageHeight = NSToCoordRound(contentPageHeight * scale);
+  }
+  // Scale down if the target is too tall.
+  if (contentPageHeight > sheetSize.height) {
+    scale *= float(sheetSize.height) / float(contentPageHeight);
+  }
+  MOZ_ASSERT(
+      scale <= 1.0f,
+      "Page-size mismatches should only have caused us to scale down, not up.");
+  return scale;
+}
+
+double nsPageFrame::GetPageOrientationRotation(nsSharedPageData* aPD) const {
+  if (!StaticPrefs::layout_css_page_orientation_enabled()) {
+    return 0.0;
+  }
+
+  if (aPD->PagesPerSheetInfo()->mNumPages == 1 && !PresContext()->IsScreen() &&
+      aPD->mPrintSettings->GetOutputFormat() !=
+          nsIPrintSettings::kOutputFormatPDF) {
+    // In the single page-per-sheet case we rotate the page by essentially
+    // rotating the entire sheet. But we can't do that when the output device
+    // doesn't support mixed sheet orientations.
+    return 0.0;
+  }
+
+  const StylePageOrientation& orientation =
+      PageContentFrame()->StylePage()->mPageOrientation;
+
+  if (orientation == StylePageOrientation::RotateLeft) {
+    return -M_PI / 2.0;
+  }
+  if (orientation == StylePageOrientation::RotateRight) {
+    return M_PI / 2.0;
+  }
+  return 0.0;
+}
+
+void nsPageFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+                                   const nsDisplayListSet& aLists) {
+  nsDisplayList content(aBuilder);
+  nsDisplayListSet set(&content, &content, &content, &content, &content,
+                       &content);
+  {
+    DisplayListClipState::AutoSaveRestore clipState(aBuilder);
+    clipState.Clear();
+
+    nsPresContext* const pc = PresContext();
+    {
+      // We need to extend the building rect to include the specified page size
+      // (scaled by the print scaling factor), in case it is larger than the
+      // physical page size. In that case the nsPageFrame will be the size of
+      // the physical page, but the child nsPageContentFrame will be the larger
+      // specified page size. The more correct way to do this would be to fully
+      // reverse the result of ComputePagesPerSheetAndPageSizeTransform to
+      // handle this scaling, but this should have the same result and is
+      // easier.
+      const float scale = pc->GetPageScale();
+      const nsSize pageSize = ComputePageSize();
+      const nsRect scaledPageRect{0, 0, NSToCoordCeil(pageSize.width / scale),
+                                  NSToCoordCeil(pageSize.height / scale)};
+      nsDisplayListBuilder::AutoBuildingDisplayList buildingForPageContentFrame(
+          aBuilder, this, scaledPageRect, scaledPageRect);
+
+      nsContainerFrame::BuildDisplayList(aBuilder, set);
+    }
+
+    if (pc->IsRootPaginatedDocument()) {
+      content.AppendNewToTop<nsDisplayHeaderFooter>(aBuilder, this);
+
+      // For print-preview, show margin guides if requested in the settings.
+      if (pc->Type() == nsPresContext::eContext_PrintPreview &&
+          mPD->mPrintSettings->GetShowMarginGuides()) {
+        content.AppendNewToTop<nsDisplayGeneric>(
+            aBuilder, this, PaintMarginGuides, "MarginGuides",
+            DisplayItemType::TYPE_MARGIN_GUIDES);
+      }
+    }
+  }
+
+  // We'll be drawing the page with a (usually-trivial)
+  // N-pages-per-sheet transform applied, so our passed-in visible rect
+  // isn't meaningful while we're drawing our children, because the
+  // transform could scale down content whose coordinates are off-screen
+  // such that it ends up on-screen. So: we temporarily update the visible
+  // rect to be the child nsPageFrame's whole frame-rect (represented in
+  // this PrintedSheetFrame's coordinate space.
+  content.AppendNewToTop<nsDisplayTransform>(
+      aBuilder, this, &content, content.GetBuildingRect(),
+      nsDisplayTransform::WithTransformGetter);
+
+  set.MoveTo(aLists);
+}
+
+//------------------------------------------------------------------------------
+void nsPageFrame::DeterminePageNum() {
+  // If we have no previous continuation, we're page 1. Otherwise, we're
+  // just one more than our previous continuation's page number.
+  auto* prevContinuation = static_cast<nsPageFrame*>(GetPrevContinuation());
+  mPageNum = prevContinuation ? prevContinuation->GetPageNum() + 1 : 1;
+}
+
+void nsPageFrame::PaintHeaderFooter(gfxContext& aRenderingContext, nsPoint aPt,
+                                    bool aDisableSubpixelAA) {
+  nsPresContext* pc = PresContext();
+
+  nsRect rect(aPt, ComputePageSize());
+  aRenderingContext.SetColor(sRGBColor::OpaqueBlack());
+
+  DrawTargetAutoDisableSubpixelAntialiasing disable(
+      aRenderingContext.GetDrawTarget(), aDisableSubpixelAA);
+
+  // Get the FontMetrics to determine width.height of strings
+  nsFontMetrics::Params params;
+  params.userFontSet = pc->GetUserFontSet();
+  params.textPerf = pc->GetTextPerfMetrics();
+  params.featureValueLookup = pc->GetFontFeatureValuesLookup();
+  RefPtr<nsFontMetrics> fontMet = pc->GetMetricsFor(mPD->mHeadFootFont, params);
+
+  nscoord ascent = fontMet->MaxAscent();
+  nscoord visibleHeight = fontMet->MaxHeight();
+
+  // print document headers and footers
+  nsString headerLeft, headerCenter, headerRight;
+  mPD->mPrintSettings->GetHeaderStrLeft(headerLeft);
+  mPD->mPrintSettings->GetHeaderStrCenter(headerCenter);
+  mPD->mPrintSettings->GetHeaderStrRight(headerRight);
+  DrawHeaderFooter(aRenderingContext, *fontMet, eHeader, headerLeft,
+                   headerCenter, headerRight, rect, ascent, visibleHeight);
+
+  nsString footerLeft, footerCenter, footerRight;
+  mPD->mPrintSettings->GetFooterStrLeft(footerLeft);
+  mPD->mPrintSettings->GetFooterStrCenter(footerCenter);
+  mPD->mPrintSettings->GetFooterStrRight(footerRight);
+  DrawHeaderFooter(aRenderingContext, *fontMet, eFooter, footerLeft,
+                   footerCenter, footerRight, rect, ascent, visibleHeight);
+}
+
+void nsPageFrame::SetSharedPageData(nsSharedPageData* aPD) {
+  mPD = aPD;
+  // Set the shared data into the page frame before reflow
+  PageContentFrame()->SetSharedPageData(mPD);
+}
+
+nsIFrame* NS_NewPageBreakFrame(PresShell* aPresShell, ComputedStyle* aStyle) {
+  MOZ_ASSERT(aPresShell, "null PresShell");
+  // check that we are only creating page break frames when printing
+  NS_ASSERTION(aPresShell->GetPresContext()->IsPaginated(),
+               "created a page break frame while not printing");
+
+  return new (aPresShell)
+      nsPageBreakFrame(aStyle, aPresShell->GetPresContext());
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsPageBreakFrame)
+
+nsPageBreakFrame::nsPageBreakFrame(ComputedStyle* aStyle,
+                                   nsPresContext* aPresContext)
+    : nsLeafFrame(aStyle, aPresContext, kClassID) {}
+
+nsPageBreakFrame::~nsPageBreakFrame() = default;
+
+nscoord nsPageBreakFrame::GetIntrinsicISize() {
+  return nsPresContext::CSSPixelsToAppUnits(1);
+}
+
+nscoord nsPageBreakFrame::GetIntrinsicBSize() { return 0; }
+
+void nsPageBreakFrame::Reflow(nsPresContext* aPresContext,
+                              ReflowOutput& aReflowOutput,
+                              const ReflowInput& aReflowInput,
+                              nsReflowStatus& aStatus) {
+  DO_GLOBAL_REFLOW_COUNT("nsPageBreakFrame");
+  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aReflowOutput, aStatus);
+  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+
+  // Override reflow, since we don't want to deal with what our
+  // computed values are.
+  const WritingMode wm = aReflowInput.GetWritingMode();
+  nscoord bSize = aReflowInput.AvailableBSize();
+  if (aReflowInput.AvailableBSize() == NS_UNCONSTRAINEDSIZE) {
+    bSize = nscoord(0);
+  } else if (GetContent()->IsHTMLElement(nsGkAtoms::legend)) {
+    // If this is a page break frame for a _rendered legend_ then it should be
+    // ignored since these frames are inserted inside the fieldset's inner
+    // frame and thus "misplaced".  nsFieldSetFrame::Reflow deals with these
+    // forced breaks explicitly instead.
+    const nsContainerFrame* parent = GetParent();
+    if (parent &&
+        parent->Style()->GetPseudoType() == PseudoStyleType::fieldsetContent) {
+      while ((parent = parent->GetParent())) {
+        if (const nsFieldSetFrame* const fieldset = do_QueryFrame(parent)) {
+          const auto* const legend = fieldset->GetLegend();
+          if (legend && legend->GetContent() == GetContent()) {
+            bSize = nscoord(0);
+          }
+          break;
+        }
+      }
+    }
+  }
+  LogicalSize finalSize(wm, GetIntrinsicISize(), bSize);
+  // round the height down to the nearest pixel
+  // XXX(mats) why???
+  finalSize.BSize(wm) -=
+      finalSize.BSize(wm) % nsPresContext::CSSPixelsToAppUnits(1);
+  aReflowOutput.SetSize(wm, finalSize);
+}
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult nsPageBreakFrame::GetFrameName(nsAString& aResult) const {
+  return MakeFrameName(u"PageBreak"_ns, aResult);
+}
+#endif