Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

1 files changed, 959 insertions, 0 deletions

diff --git a/layout/base/DisplayPortUtils.cpp b/layout/base/DisplayPortUtils.cpp
new file mode 100644
index 0000000000..bc3fd8a9c4
--- /dev/null
+++ b/layout/base/DisplayPortUtils.cpp
@@ -0,0 +1,959 @@
+/* -*- 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 "DisplayPortUtils.h"
+
+#include "FrameMetrics.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/gfx/Point.h"
+#include "mozilla/layers/APZPublicUtils.h"
+#include "mozilla/layers/CompositorBridgeChild.h"
+#include "mozilla/layers/LayersMessageUtils.h"
+#include "mozilla/layers/PAPZ.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_layers.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "nsIScrollableFrame.h"
+#include "nsLayoutUtils.h"
+#include "nsPlaceholderFrame.h"
+#include "nsSubDocumentFrame.h"
+#include "RetainedDisplayListBuilder.h"
+#include "WindowRenderer.h"
+
+#include <ostream>
+
+namespace mozilla {
+
+using gfx::IntSize;
+
+using layers::FrameMetrics;
+using layers::ScrollableLayerGuid;
+
+typedef ScrollableLayerGuid::ViewID ViewID;
+
+static LazyLogModule sDisplayportLog("apz.displayport");
+
+/* static */
+DisplayPortMargins DisplayPortMargins::FromAPZ(const ScreenMargin& aMargins,
+                                               const CSSPoint& aVisualOffset,
+                                               const CSSPoint& aLayoutOffset) {
+  return DisplayPortMargins{aMargins, aVisualOffset, aLayoutOffset};
+}
+
+/* static */
+DisplayPortMargins DisplayPortMargins::ForScrollFrame(
+    nsIScrollableFrame* aScrollFrame, const ScreenMargin& aMargins) {
+  CSSPoint visualOffset;
+  CSSPoint layoutOffset;
+  if (aScrollFrame) {
+    nsIFrame* scrollFrame = do_QueryFrame(aScrollFrame);
+    PresShell* presShell = scrollFrame->PresShell();
+    layoutOffset = CSSPoint::FromAppUnits(aScrollFrame->GetScrollPosition());
+    if (aScrollFrame->IsRootScrollFrameOfDocument()) {
+      visualOffset =
+          CSSPoint::FromAppUnits(presShell->GetVisualViewportOffset());
+
+    } else {
+      visualOffset = layoutOffset;
+    }
+  }
+  return DisplayPortMargins{aMargins, visualOffset, layoutOffset};
+}
+
+/* static */
+DisplayPortMargins DisplayPortMargins::ForContent(
+    nsIContent* aContent, const ScreenMargin& aMargins) {
+  return ForScrollFrame(
+      aContent ? nsLayoutUtils::FindScrollableFrameFor(aContent) : nullptr,
+      aMargins);
+}
+
+ScreenMargin DisplayPortMargins::GetRelativeToLayoutViewport(
+    ContentGeometryType aGeometryType, nsIScrollableFrame* aScrollableFrame,
+    const CSSToScreenScale2D& aDisplayportScale) const {
+  // APZ wants |mMargins| applied relative to the visual viewport.
+  // The main-thread painting code applies margins relative to
+  // the layout viewport. To get the main thread to paint the
+  // area APZ wants, apply a translation between the two. The
+  // magnitude of the translation depends on whether we are
+  // applying the displayport to scrolled or fixed content.
+  CSSPoint scrollDeltaCss =
+      ComputeAsyncTranslation(aGeometryType, aScrollableFrame);
+  ScreenPoint scrollDelta = scrollDeltaCss * aDisplayportScale;
+  ScreenMargin margins = mMargins;
+  margins.left -= scrollDelta.x;
+  margins.right += scrollDelta.x;
+  margins.top -= scrollDelta.y;
+  margins.bottom += scrollDelta.y;
+  return margins;
+}
+
+std::ostream& operator<<(std::ostream& aOs,
+                         const DisplayPortMargins& aMargins) {
+  if (aMargins.mVisualOffset == CSSPoint() &&
+      aMargins.mLayoutOffset == CSSPoint()) {
+    aOs << aMargins.mMargins;
+  } else {
+    aOs << "{" << aMargins.mMargins << "," << aMargins.mVisualOffset << ","
+        << aMargins.mLayoutOffset << "}";
+  }
+  return aOs;
+}
+
+CSSPoint DisplayPortMargins::ComputeAsyncTranslation(
+    ContentGeometryType aGeometryType,
+    nsIScrollableFrame* aScrollableFrame) const {
+  // If we are applying the displayport to scrolled content, the
+  // translation is the entire difference between the visual and
+  // layout offsets.
+  if (aGeometryType == ContentGeometryType::Scrolled) {
+    return mVisualOffset - mLayoutOffset;
+  }
+
+  // If we are applying the displayport to fixed content, only
+  // part of the difference between the visual and layout offsets
+  // should be applied. This is because fixed content remains fixed
+  // to the layout viewport, and some of the async delta between
+  // the visual and layout offsets can drag the layout viewport
+  // with it. We want only the remaining delta, i.e. the offset of
+  // the visual viewport relative to the (async-scrolled) layout
+  // viewport.
+  if (!aScrollableFrame) {
+    // Displayport on a non-scrolling frame for some reason.
+    // There will be no divergence between the two viewports.
+    return CSSPoint();
+  }
+  // Fixed content is always fixed to an RSF.
+  MOZ_ASSERT(aScrollableFrame->IsRootScrollFrameOfDocument());
+  nsIFrame* scrollFrame = do_QueryFrame(aScrollableFrame);
+  if (!scrollFrame->PresShell()->IsVisualViewportSizeSet()) {
+    // Zooming is disabled, so the layout viewport tracks the
+    // visual viewport completely.
+    return CSSPoint();
+  }
+  // Use KeepLayoutViewportEnclosingViewportVisual() to compute
+  // an async layout viewport the way APZ would.
+  const CSSRect visualViewport{
+      mVisualOffset,
+      // TODO: There are probably some edge cases here around async zooming
+      // that are not currently being handled properly. For proper handling,
+      // we'd likely need to save APZ's async zoom when populating
+      // mVisualOffset, and using it to adjust the visual viewport size here.
+      // Note that any incorrectness caused by this will only occur transiently
+      // during async zooming.
+      CSSSize::FromAppUnits(scrollFrame->PresShell()->GetVisualViewportSize())};
+  const CSSRect scrollableRect = CSSRect::FromAppUnits(
+      nsLayoutUtils::CalculateExpandedScrollableRect(scrollFrame));
+  CSSRect asyncLayoutViewport{
+      mLayoutOffset,
+      CSSSize::FromAppUnits(aScrollableFrame->GetScrollPortRect().Size())};
+  FrameMetrics::KeepLayoutViewportEnclosingVisualViewport(
+      visualViewport, scrollableRect, /* out */ asyncLayoutViewport);
+  return mVisualOffset - asyncLayoutViewport.TopLeft();
+}
+
+static nsRect GetDisplayPortFromRectData(nsIContent* aContent,
+                                         DisplayPortPropertyData* aRectData) {
+  // In the case where the displayport is set as a rect, we assume it is
+  // already aligned and clamped as necessary. The burden to do that is
+  // on the setter of the displayport. In practice very few places set the
+  // displayport directly as a rect (mostly tests).
+  return aRectData->mRect;
+}
+
+static nsRect GetDisplayPortFromMarginsData(
+    nsIContent* aContent, DisplayPortMarginsPropertyData* aMarginsData,
+    const DisplayPortOptions& aOptions) {
+  // In the case where the displayport is set via margins, we apply the margins
+  // to a base rect. Then we align the expanded rect based on the alignment
+  // requested, and finally, clamp it to the size of the scrollable rect.
+
+  nsRect base;
+  if (nsRect* baseData = static_cast<nsRect*>(
+          aContent->GetProperty(nsGkAtoms::DisplayPortBase))) {
+    base = *baseData;
+  } else {
+    // In theory we shouldn't get here, but we do sometimes (see bug 1212136).
+    // Fall through for graceful handling.
+  }
+
+  nsIFrame* frame = nsLayoutUtils::GetScrollFrameFromContent(aContent);
+  if (!frame) {
+    // Turns out we can't really compute it. Oops. We still should return
+    // something sane.
+    NS_WARNING(
+        "Attempting to get a displayport from a content with no primary "
+        "frame!");
+    return base;
+  }
+
+  bool isRoot = false;
+  if (aContent->OwnerDoc()->GetRootElement() == aContent) {
+    isRoot = true;
+  }
+
+  nsIScrollableFrame* scrollableFrame = frame->GetScrollTargetFrame();
+  nsPoint scrollPos;
+  if (scrollableFrame) {
+    scrollPos = scrollableFrame->GetScrollPosition();
+  }
+
+  nsPresContext* presContext = frame->PresContext();
+  int32_t auPerDevPixel = presContext->AppUnitsPerDevPixel();
+
+  LayoutDeviceToScreenScale2D res =
+      LayoutDeviceToParentLayerScale(
+          presContext->PresShell()->GetCumulativeResolution()) *
+      nsLayoutUtils::GetTransformToAncestorScaleCrossProcessForFrameMetrics(
+          frame);
+
+  // Calculate the expanded scrollable rect, which we'll be clamping the
+  // displayport to.
+  nsRect expandedScrollableRect =
+      nsLayoutUtils::CalculateExpandedScrollableRect(frame);
+
+  // GetTransformToAncestorScale() can return 0. In this case, just return the
+  // base rect (clamped to the expanded scrollable rect), as other calculations
+  // would run into divisions by zero.
+  if (res == LayoutDeviceToScreenScale2D(0, 0)) {
+    // Make sure the displayport remains within the scrollable rect.
+    return base.MoveInsideAndClamp(expandedScrollableRect - scrollPos);
+  }
+
+  // First convert the base rect to screen pixels
+  LayoutDeviceToScreenScale2D parentRes = res;
+  if (isRoot) {
+    // the base rect for root scroll frames is specified in the parent document
+    // coordinate space, so it doesn't include the local resolution.
+    float localRes = presContext->PresShell()->GetResolution();
+    parentRes.xScale /= localRes;
+    parentRes.yScale /= localRes;
+  }
+  ScreenRect screenRect =
+      LayoutDeviceRect::FromAppUnits(base, auPerDevPixel) * parentRes;
+
+  // Note on the correctness of applying the alignment in Screen space:
+  //   The correct space to apply the alignment in would be Layer space, but
+  //   we don't necessarily know the scale to convert to Layer space at this
+  //   point because Layout may not yet have chosen the resolution at which to
+  //   render (it chooses that in FrameLayerBuilder, but this can be called
+  //   during display list building). Therefore, we perform the alignment in
+  //   Screen space, which basically assumes that Layout chose to render at
+  //   screen resolution; since this is what Layout does most of the time,
+  //   this is a good approximation. A proper solution would involve moving
+  //   the choosing of the resolution to display-list building time.
+  ScreenSize alignment;
+
+  PresShell* presShell = presContext->PresShell();
+  MOZ_ASSERT(presShell);
+
+  ScreenMargin margins = aMarginsData->mMargins.GetRelativeToLayoutViewport(
+      aOptions.mGeometryType, scrollableFrame,
+      presContext->CSSToDevPixelScale() * res);
+
+  if (presShell->IsDisplayportSuppressed() ||
+      aContent->GetProperty(nsGkAtoms::MinimalDisplayPort)) {
+    alignment = ScreenSize(1, 1);
+  } else {
+    // Moving the displayport is relatively expensive with WR so we use a larger
+    // alignment that causes the displayport to move less frequently. The
+    // alignment scales up with the size of the base rect so larger scrollframes
+    // use a larger alignment, but we clamp the alignment to a power of two
+    // between 128 and 1024 (inclusive).
+    // This naturally also increases the size of the displayport compared to
+    // always using a 128 alignment, so the displayport multipliers are also
+    // correspondingly smaller when WR is enabled to prevent the displayport
+    // from becoming too big.
+    IntSize multiplier =
+        layers::apz::GetDisplayportAlignmentMultiplier(screenRect.Size());
+    alignment = ScreenSize(128 * multiplier.width, 128 * multiplier.height);
+  }
+
+  // Avoid division by zero.
+  if (alignment.width == 0) {
+    alignment.width = 128;
+  }
+  if (alignment.height == 0) {
+    alignment.height = 128;
+  }
+
+  // Expand the rect by the margins
+  screenRect.Inflate(margins);
+
+  ScreenPoint scrollPosScreen =
+      LayoutDevicePoint::FromAppUnits(scrollPos, auPerDevPixel) * res;
+
+  // Align the display port.
+  screenRect += scrollPosScreen;
+  float x = alignment.width * floor(screenRect.x / alignment.width);
+  float y = alignment.height * floor(screenRect.y / alignment.height);
+  float w = alignment.width * ceil(screenRect.width / alignment.width + 1);
+  float h = alignment.height * ceil(screenRect.height / alignment.height + 1);
+  screenRect = ScreenRect(x, y, w, h);
+  screenRect -= scrollPosScreen;
+
+  // Convert the aligned rect back into app units.
+  nsRect result = LayoutDeviceRect::ToAppUnits(screenRect / res, auPerDevPixel);
+
+  // Make sure the displayport remains within the scrollable rect.
+  result = result.MoveInsideAndClamp(expandedScrollableRect - scrollPos);
+
+  return result;
+}
+
+static bool GetDisplayPortData(
+    nsIContent* aContent, DisplayPortPropertyData** aOutRectData,
+    DisplayPortMarginsPropertyData** aOutMarginsData) {
+  MOZ_ASSERT(aOutRectData && aOutMarginsData);
+
+  *aOutRectData = static_cast<DisplayPortPropertyData*>(
+      aContent->GetProperty(nsGkAtoms::DisplayPort));
+  *aOutMarginsData = static_cast<DisplayPortMarginsPropertyData*>(
+      aContent->GetProperty(nsGkAtoms::DisplayPortMargins));
+
+  if (!*aOutRectData && !*aOutMarginsData) {
+    // This content element has no displayport data at all
+    return false;
+  }
+
+  if (*aOutRectData && *aOutMarginsData) {
+    // choose margins if equal priority
+    if ((*aOutRectData)->mPriority > (*aOutMarginsData)->mPriority) {
+      *aOutMarginsData = nullptr;
+    } else {
+      *aOutRectData = nullptr;
+    }
+  }
+
+  NS_ASSERTION((*aOutRectData == nullptr) != (*aOutMarginsData == nullptr),
+               "Only one of aOutRectData or aOutMarginsData should be set!");
+
+  return true;
+}
+
+static bool GetWasDisplayPortPainted(nsIContent* aContent) {
+  DisplayPortPropertyData* rectData = nullptr;
+  DisplayPortMarginsPropertyData* marginsData = nullptr;
+
+  if (!GetDisplayPortData(aContent, &rectData, &marginsData)) {
+    return false;
+  }
+
+  return rectData ? rectData->mPainted : marginsData->mPainted;
+}
+
+bool DisplayPortUtils::IsMissingDisplayPortBaseRect(nsIContent* aContent) {
+  DisplayPortPropertyData* rectData = nullptr;
+  DisplayPortMarginsPropertyData* marginsData = nullptr;
+
+  if (GetDisplayPortData(aContent, &rectData, &marginsData) && marginsData) {
+    return !aContent->GetProperty(nsGkAtoms::DisplayPortBase);
+  }
+
+  return false;
+}
+
+static void TranslateFromScrollPortToScrollFrame(nsIContent* aContent,
+                                                 nsRect* aRect) {
+  MOZ_ASSERT(aRect);
+  if (nsIScrollableFrame* scrollableFrame =
+          nsLayoutUtils::FindScrollableFrameFor(aContent)) {
+    *aRect += scrollableFrame->GetScrollPortRect().TopLeft();
+  }
+}
+
+static bool GetDisplayPortImpl(nsIContent* aContent, nsRect* aResult,
+                               const DisplayPortOptions& aOptions) {
+  DisplayPortPropertyData* rectData = nullptr;
+  DisplayPortMarginsPropertyData* marginsData = nullptr;
+
+  if (!GetDisplayPortData(aContent, &rectData, &marginsData)) {
+    return false;
+  }
+
+  nsIFrame* frame = aContent->GetPrimaryFrame();
+  if (frame && !frame->PresShell()->AsyncPanZoomEnabled()) {
+    return false;
+  }
+
+  if (!aResult) {
+    // We have displayport data, but the caller doesn't want the actual
+    // rect, so we don't need to actually compute it.
+    return true;
+  }
+
+  bool isDisplayportSuppressed = false;
+
+  if (frame) {
+    nsPresContext* presContext = frame->PresContext();
+    MOZ_ASSERT(presContext);
+    PresShell* presShell = presContext->PresShell();
+    MOZ_ASSERT(presShell);
+    isDisplayportSuppressed = presShell->IsDisplayportSuppressed();
+  }
+
+  nsRect result;
+  if (rectData) {
+    result = GetDisplayPortFromRectData(aContent, rectData);
+  } else if (isDisplayportSuppressed ||
+             nsLayoutUtils::ShouldDisableApzForElement(aContent) ||
+             aContent->GetProperty(nsGkAtoms::MinimalDisplayPort)) {
+    // Make a copy of the margins data but set the margins to empty.
+    // Do not create a new DisplayPortMargins object with
+    // DisplayPortMargins::Empty(), because that will record the visual
+    // and layout scroll offsets in place right now on the DisplayPortMargins,
+    // and those are only meant to be recorded when the margins are stored.
+    DisplayPortMarginsPropertyData noMargins = *marginsData;
+    noMargins.mMargins.mMargins = ScreenMargin();
+    result = GetDisplayPortFromMarginsData(aContent, &noMargins, aOptions);
+  } else {
+    result = GetDisplayPortFromMarginsData(aContent, marginsData, aOptions);
+  }
+
+  if (aOptions.mRelativeTo == DisplayportRelativeTo::ScrollFrame) {
+    TranslateFromScrollPortToScrollFrame(aContent, &result);
+  }
+
+  *aResult = result;
+  return true;
+}
+
+bool DisplayPortUtils::GetDisplayPort(nsIContent* aContent, nsRect* aResult,
+                                      const DisplayPortOptions& aOptions) {
+  return GetDisplayPortImpl(aContent, aResult, aOptions);
+}
+
+bool DisplayPortUtils::HasDisplayPort(nsIContent* aContent) {
+  return GetDisplayPort(aContent, nullptr);
+}
+
+bool DisplayPortUtils::HasPaintedDisplayPort(nsIContent* aContent) {
+  DisplayPortPropertyData* rectData = nullptr;
+  DisplayPortMarginsPropertyData* marginsData = nullptr;
+  GetDisplayPortData(aContent, &rectData, &marginsData);
+  if (rectData) {
+    return rectData->mPainted;
+  }
+  if (marginsData) {
+    return marginsData->mPainted;
+  }
+  return false;
+}
+
+void DisplayPortUtils::MarkDisplayPortAsPainted(nsIContent* aContent) {
+  DisplayPortPropertyData* rectData = nullptr;
+  DisplayPortMarginsPropertyData* marginsData = nullptr;
+  GetDisplayPortData(aContent, &rectData, &marginsData);
+  MOZ_ASSERT(rectData || marginsData,
+             "MarkDisplayPortAsPainted should only be called for an element "
+             "with a displayport");
+  if (rectData) {
+    rectData->mPainted = true;
+  }
+  if (marginsData) {
+    marginsData->mPainted = true;
+  }
+}
+
+bool DisplayPortUtils::HasNonMinimalDisplayPort(nsIContent* aContent) {
+  return HasDisplayPort(aContent) &&
+         !aContent->GetProperty(nsGkAtoms::MinimalDisplayPort);
+}
+
+bool DisplayPortUtils::HasNonMinimalNonZeroDisplayPort(nsIContent* aContent) {
+  if (!HasDisplayPort(aContent)) {
+    return false;
+  }
+  if (aContent->GetProperty(nsGkAtoms::MinimalDisplayPort)) {
+    return false;
+  }
+
+  DisplayPortMarginsPropertyData* currentData =
+      static_cast<DisplayPortMarginsPropertyData*>(
+          aContent->GetProperty(nsGkAtoms::DisplayPortMargins));
+
+  if (!currentData) {
+    // We have a display port, so if we don't have margin data we must have rect
+    // data. We consider such as non zero and non minimal, it's probably not too
+    // important as display port rects are only used in tests.
+    return true;
+  }
+
+  if (currentData->mMargins.mMargins != ScreenMargin()) {
+    return true;
+  }
+
+  return false;
+}
+
+/* static */
+bool DisplayPortUtils::GetDisplayPortForVisibilityTesting(nsIContent* aContent,
+                                                          nsRect* aResult) {
+  MOZ_ASSERT(aResult);
+  return GetDisplayPortImpl(
+      aContent, aResult,
+      DisplayPortOptions().With(DisplayportRelativeTo::ScrollFrame));
+}
+
+void DisplayPortUtils::InvalidateForDisplayPortChange(
+    nsIContent* aContent, bool aHadDisplayPort, const nsRect& aOldDisplayPort,
+    const nsRect& aNewDisplayPort, RepaintMode aRepaintMode) {
+  if (aRepaintMode != RepaintMode::Repaint) {
+    return;
+  }
+
+  bool changed =
+      !aHadDisplayPort || !aOldDisplayPort.IsEqualEdges(aNewDisplayPort);
+
+  nsIFrame* frame = nsLayoutUtils::GetScrollFrameFromContent(aContent);
+  if (frame) {
+    frame = do_QueryFrame(frame->GetScrollTargetFrame());
+  }
+
+  if (changed && frame) {
+    // It is important to call SchedulePaint on the same frame that we set the
+    // dirty rect properties on so we can find the frame later to remove the
+    // properties.
+    frame->SchedulePaint();
+
+    if (!nsLayoutUtils::AreRetainedDisplayListsEnabled()) {
+      return;
+    }
+
+    if (StaticPrefs::layout_display_list_retain_sc()) {
+      // DisplayListBuildingDisplayPortRect property is not used when retain sc
+      // mode is enabled.
+      return;
+    }
+
+    auto* builder = nsLayoutUtils::GetRetainedDisplayListBuilder(frame);
+    if (!builder) {
+      return;
+    }
+
+    bool found;
+    nsRect* rect = frame->GetProperty(
+        nsDisplayListBuilder::DisplayListBuildingDisplayPortRect(), &found);
+
+    if (!found) {
+      rect = new nsRect();
+      frame->AddProperty(
+          nsDisplayListBuilder::DisplayListBuildingDisplayPortRect(), rect);
+      frame->SetHasOverrideDirtyRegion(true);
+
+      DL_LOGV("Adding display port building rect for frame %p\n", frame);
+      RetainedDisplayListData* data = builder->Data();
+      data->Flags(frame) += RetainedDisplayListData::FrameFlag::HasProps;
+    } else {
+      MOZ_ASSERT(rect, "this property should only store non-null values");
+    }
+
+    if (aHadDisplayPort) {
+      // We only need to build a display list for any new areas added
+      nsRegion newRegion(aNewDisplayPort);
+      newRegion.SubOut(aOldDisplayPort);
+      rect->UnionRect(*rect, newRegion.GetBounds());
+    } else {
+      rect->UnionRect(*rect, aNewDisplayPort);
+    }
+  }
+}
+
+bool DisplayPortUtils::SetDisplayPortMargins(
+    nsIContent* aContent, PresShell* aPresShell,
+    const DisplayPortMargins& aMargins,
+    ClearMinimalDisplayPortProperty aClearMinimalDisplayPortProperty,
+    uint32_t aPriority, RepaintMode aRepaintMode) {
+  MOZ_ASSERT(aContent);
+  MOZ_ASSERT(aContent->GetComposedDoc() == aPresShell->GetDocument());
+
+  DisplayPortMarginsPropertyData* currentData =
+      static_cast<DisplayPortMarginsPropertyData*>(
+          aContent->GetProperty(nsGkAtoms::DisplayPortMargins));
+  if (currentData && currentData->mPriority > aPriority) {
+    return false;
+  }
+
+  if (currentData && currentData->mMargins.mVisualOffset != CSSPoint() &&
+      aMargins.mVisualOffset == CSSPoint()) {
+    // If we hit this, then it's possible that we're setting a displayport
+    // that is wrong because the old one had a layout/visual adjustment and
+    // the new one does not.
+    MOZ_LOG(sDisplayportLog, LogLevel::Warning,
+            ("Dropping visual offset %s",
+             ToString(currentData->mMargins.mVisualOffset).c_str()));
+  }
+
+  nsIFrame* scrollFrame = nsLayoutUtils::GetScrollFrameFromContent(aContent);
+
+  nsRect oldDisplayPort;
+  bool hadDisplayPort = false;
+  bool wasPainted = GetWasDisplayPortPainted(aContent);
+  if (scrollFrame) {
+    // We only use the two return values from this function to call
+    // InvalidateForDisplayPortChange. InvalidateForDisplayPortChange does
+    // nothing if aContent does not have a frame. So getting the displayport is
+    // useless if the content has no frame, so we avoid calling this to avoid
+    // triggering a warning about not having a frame.
+    hadDisplayPort = GetDisplayPort(aContent, &oldDisplayPort);
+  }
+
+  aContent->SetProperty(
+      nsGkAtoms::DisplayPortMargins,
+      new DisplayPortMarginsPropertyData(aMargins, aPriority, wasPainted),
+      nsINode::DeleteProperty<DisplayPortMarginsPropertyData>);
+
+  if (aClearMinimalDisplayPortProperty ==
+      ClearMinimalDisplayPortProperty::Yes) {
+    if (MOZ_LOG_TEST(sDisplayportLog, LogLevel::Debug) &&
+        aContent->GetProperty(nsGkAtoms::MinimalDisplayPort)) {
+      mozilla::layers::ScrollableLayerGuid::ViewID viewID =
+          mozilla::layers::ScrollableLayerGuid::NULL_SCROLL_ID;
+      nsLayoutUtils::FindIDFor(aContent, &viewID);
+      MOZ_LOG(sDisplayportLog, LogLevel::Debug,
+              ("SetDisplayPortMargins removing MinimalDisplayPort prop on "
+               "scrollId=%" PRIu64 "\n",
+               viewID));
+    }
+    aContent->RemoveProperty(nsGkAtoms::MinimalDisplayPort);
+  }
+
+  nsIScrollableFrame* scrollableFrame =
+      scrollFrame ? scrollFrame->GetScrollTargetFrame() : nullptr;
+  if (!scrollableFrame) {
+    return true;
+  }
+
+  nsRect newDisplayPort;
+  DebugOnly<bool> hasDisplayPort = GetDisplayPort(aContent, &newDisplayPort);
+  MOZ_ASSERT(hasDisplayPort);
+
+  if (MOZ_LOG_TEST(sDisplayportLog, LogLevel::Debug)) {
+    mozilla::layers::ScrollableLayerGuid::ViewID viewID =
+        mozilla::layers::ScrollableLayerGuid::NULL_SCROLL_ID;
+    nsLayoutUtils::FindIDFor(aContent, &viewID);
+    if (!hadDisplayPort) {
+      MOZ_LOG(sDisplayportLog, LogLevel::Debug,
+              ("SetDisplayPortMargins %s on scrollId=%" PRIu64 ", newDp=%s\n",
+               ToString(aMargins).c_str(), viewID,
+               ToString(newDisplayPort).c_str()));
+    } else {
+      // Use verbose level logging for when an existing displayport got its
+      // margins updated.
+      MOZ_LOG(sDisplayportLog, LogLevel::Verbose,
+              ("SetDisplayPortMargins %s on scrollId=%" PRIu64 ", newDp=%s\n",
+               ToString(aMargins).c_str(), viewID,
+               ToString(newDisplayPort).c_str()));
+    }
+  }
+
+  InvalidateForDisplayPortChange(aContent, hadDisplayPort, oldDisplayPort,
+                                 newDisplayPort, aRepaintMode);
+
+  scrollableFrame->TriggerDisplayPortExpiration();
+
+  // Display port margins changing means that the set of visible frames may
+  // have drastically changed. Check if we should schedule an update.
+  hadDisplayPort =
+      scrollableFrame->GetDisplayPortAtLastApproximateFrameVisibilityUpdate(
+          &oldDisplayPort);
+
+  bool needVisibilityUpdate = !hadDisplayPort;
+  // Check if the total size has changed by a large factor.
+  if (!needVisibilityUpdate) {
+    if ((newDisplayPort.width > 2 * oldDisplayPort.width) ||
+        (oldDisplayPort.width > 2 * newDisplayPort.width) ||
+        (newDisplayPort.height > 2 * oldDisplayPort.height) ||
+        (oldDisplayPort.height > 2 * newDisplayPort.height)) {
+      needVisibilityUpdate = true;
+    }
+  }
+  // Check if it's moved by a significant amount.
+  if (!needVisibilityUpdate) {
+    if (nsRect* baseData = static_cast<nsRect*>(
+            aContent->GetProperty(nsGkAtoms::DisplayPortBase))) {
+      nsRect base = *baseData;
+      if ((std::abs(newDisplayPort.X() - oldDisplayPort.X()) > base.width) ||
+          (std::abs(newDisplayPort.XMost() - oldDisplayPort.XMost()) >
+           base.width) ||
+          (std::abs(newDisplayPort.Y() - oldDisplayPort.Y()) > base.height) ||
+          (std::abs(newDisplayPort.YMost() - oldDisplayPort.YMost()) >
+           base.height)) {
+        needVisibilityUpdate = true;
+      }
+    }
+  }
+  if (needVisibilityUpdate) {
+    aPresShell->ScheduleApproximateFrameVisibilityUpdateNow();
+  }
+
+  return true;
+}
+
+void DisplayPortUtils::SetDisplayPortBase(nsIContent* aContent,
+                                          const nsRect& aBase) {
+  if (MOZ_LOG_TEST(sDisplayportLog, LogLevel::Verbose)) {
+    ViewID viewId = nsLayoutUtils::FindOrCreateIDFor(aContent);
+    MOZ_LOG(sDisplayportLog, LogLevel::Verbose,
+            ("Setting base rect %s for scrollId=%" PRIu64 "\n",
+             ToString(aBase).c_str(), viewId));
+  }
+  aContent->SetProperty(nsGkAtoms::DisplayPortBase, new nsRect(aBase),
+                        nsINode::DeleteProperty<nsRect>);
+}
+
+void DisplayPortUtils::SetDisplayPortBaseIfNotSet(nsIContent* aContent,
+                                                  const nsRect& aBase) {
+  if (!aContent->GetProperty(nsGkAtoms::DisplayPortBase)) {
+    SetDisplayPortBase(aContent, aBase);
+  }
+}
+
+void DisplayPortUtils::RemoveDisplayPort(nsIContent* aContent) {
+  aContent->RemoveProperty(nsGkAtoms::DisplayPort);
+  aContent->RemoveProperty(nsGkAtoms::DisplayPortMargins);
+}
+
+bool DisplayPortUtils::ViewportHasDisplayPort(nsPresContext* aPresContext) {
+  nsIFrame* rootScrollFrame = aPresContext->PresShell()->GetRootScrollFrame();
+  return rootScrollFrame && HasDisplayPort(rootScrollFrame->GetContent());
+}
+
+bool DisplayPortUtils::IsFixedPosFrameInDisplayPort(const nsIFrame* aFrame) {
+  // Fixed-pos frames are parented by the viewport frame or the page content
+  // frame. We'll assume that printing/print preview don't have displayports for
+  // their pages!
+  nsIFrame* parent = aFrame->GetParent();
+  if (!parent || parent->GetParent() ||
+      aFrame->StyleDisplay()->mPosition != StylePositionProperty::Fixed) {
+    return false;
+  }
+  return ViewportHasDisplayPort(aFrame->PresContext());
+}
+
+// We want to this return true for the scroll frame, but not the
+// scrolled frame (which has the same content).
+bool DisplayPortUtils::FrameHasDisplayPort(nsIFrame* aFrame,
+                                           const nsIFrame* aScrolledFrame) {
+  if (!aFrame->GetContent() || !HasDisplayPort(aFrame->GetContent())) {
+    return false;
+  }
+  nsIScrollableFrame* sf = do_QueryFrame(aFrame);
+  if (sf) {
+    if (aScrolledFrame && aScrolledFrame != sf->GetScrolledFrame()) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+bool DisplayPortUtils::CalculateAndSetDisplayPortMargins(
+    nsIScrollableFrame* aScrollFrame, RepaintMode aRepaintMode) {
+  nsIFrame* frame = do_QueryFrame(aScrollFrame);
+  MOZ_ASSERT(frame);
+  nsIContent* content = frame->GetContent();
+  MOZ_ASSERT(content);
+
+  FrameMetrics metrics =
+      nsLayoutUtils::CalculateBasicFrameMetrics(aScrollFrame);
+  ScreenMargin displayportMargins = layers::apz::CalculatePendingDisplayPort(
+      metrics, ParentLayerPoint(0.0f, 0.0f));
+  PresShell* presShell = frame->PresContext()->GetPresShell();
+
+  DisplayPortMargins margins =
+      DisplayPortMargins::ForScrollFrame(aScrollFrame, displayportMargins);
+
+  return SetDisplayPortMargins(content, presShell, margins,
+                               ClearMinimalDisplayPortProperty::Yes, 0,
+                               aRepaintMode);
+}
+
+bool DisplayPortUtils::MaybeCreateDisplayPort(
+    nsDisplayListBuilder* aBuilder, nsIFrame* aScrollFrame,
+    nsIScrollableFrame* aScrollFrameAsScrollable, RepaintMode aRepaintMode) {
+  nsIContent* content = aScrollFrame->GetContent();
+  if (!content) {
+    return false;
+  }
+
+  bool haveDisplayPort = HasNonMinimalNonZeroDisplayPort(content);
+
+  // We perform an optimization where we ensure that at least one
+  // async-scrollable frame (i.e. one that WantsAsyncScroll()) has a
+  // displayport. If that's not the case yet, and we are async-scrollable, we
+  // will get a displayport.
+  if (aBuilder->IsPaintingToWindow() &&
+      nsLayoutUtils::AsyncPanZoomEnabled(aScrollFrame) &&
+      !aBuilder->HaveScrollableDisplayPort() &&
+      aScrollFrameAsScrollable->WantAsyncScroll()) {
+    // If we don't already have a displayport, calculate and set one.
+    if (!haveDisplayPort) {
+      // We only use the viewId for logging purposes, but create it
+      // unconditionally to minimize impact of enabling logging. If we don't
+      // assign a viewId here it will get assigned later anyway so functionally
+      // there should be no difference.
+      ViewID viewId = nsLayoutUtils::FindOrCreateIDFor(content);
+      MOZ_LOG(
+          sDisplayportLog, LogLevel::Debug,
+          ("Setting DP on first-encountered scrollId=%" PRIu64 "\n", viewId));
+
+      CalculateAndSetDisplayPortMargins(aScrollFrameAsScrollable, aRepaintMode);
+#ifdef DEBUG
+      haveDisplayPort = HasNonMinimalDisplayPort(content);
+      MOZ_ASSERT(haveDisplayPort,
+                 "should have a displayport after having just set it");
+#endif
+    }
+
+    // Record that the we now have a scrollable display port.
+    aBuilder->SetHaveScrollableDisplayPort();
+    return true;
+  }
+  return false;
+}
+void DisplayPortUtils::SetZeroMarginDisplayPortOnAsyncScrollableAncestors(
+    nsIFrame* aFrame) {
+  nsIFrame* frame = aFrame;
+  while (frame) {
+    frame = nsLayoutUtils::GetParentOrPlaceholderForCrossDoc(frame);
+    if (!frame) {
+      break;
+    }
+    nsIScrollableFrame* scrollAncestor =
+        nsLayoutUtils::GetAsyncScrollableAncestorFrame(frame);
+    if (!scrollAncestor) {
+      break;
+    }
+    frame = do_QueryFrame(scrollAncestor);
+    MOZ_ASSERT(frame);
+    MOZ_ASSERT(scrollAncestor->WantAsyncScroll() ||
+               frame->PresShell()->GetRootScrollFrame() == frame);
+    if (nsLayoutUtils::AsyncPanZoomEnabled(frame) &&
+        !HasDisplayPort(frame->GetContent())) {
+      SetDisplayPortMargins(frame->GetContent(), frame->PresShell(),
+                            DisplayPortMargins::Empty(frame->GetContent()),
+                            ClearMinimalDisplayPortProperty::No, 0,
+                            RepaintMode::Repaint);
+    }
+  }
+}
+
+bool DisplayPortUtils::MaybeCreateDisplayPortInFirstScrollFrameEncountered(
+    nsIFrame* aFrame, nsDisplayListBuilder* aBuilder) {
+  // Don't descend into the tab bar in chrome, it can be very large and does not
+  // contain any async scrollable elements.
+  if (XRE_IsParentProcess() && aFrame->GetContent() &&
+      aFrame->GetContent()->GetID() == nsGkAtoms::tabbrowser_arrowscrollbox) {
+    return false;
+  }
+  if (nsIScrollableFrame* sf = do_QueryFrame(aFrame)) {
+    if (MaybeCreateDisplayPort(aBuilder, aFrame, sf, RepaintMode::Repaint)) {
+      // If this was the first displayport found in the first scroll frame
+      // encountered, mark the scroll frame with the current paint sequence
+      // number. This is used later to ensure the displayport created is
+      // never expired. When there is a scrollable frame with a first
+      // scrollable sequence number found that does not match the current
+      // paint sequence number (may occur if the dom was mutated in some way),
+      // the value will be reset.
+      sf->SetIsFirstScrollableFrameSequenceNumber(
+          Some(nsDisplayListBuilder::GetPaintSequenceNumber()));
+      return true;
+    }
+  }
+  if (aFrame->IsPlaceholderFrame()) {
+    nsPlaceholderFrame* placeholder = static_cast<nsPlaceholderFrame*>(aFrame);
+    if (MaybeCreateDisplayPortInFirstScrollFrameEncountered(
+            placeholder->GetOutOfFlowFrame(), aBuilder)) {
+      return true;
+    }
+  }
+  if (aFrame->IsSubDocumentFrame()) {
+    PresShell* presShell = static_cast<nsSubDocumentFrame*>(aFrame)
+                               ->GetSubdocumentPresShellForPainting(0);
+    if (nsIFrame* root = presShell ? presShell->GetRootFrame() : nullptr) {
+      if (MaybeCreateDisplayPortInFirstScrollFrameEncountered(root, aBuilder)) {
+        return true;
+      }
+    }
+  }
+  if (aFrame->StyleUIReset()->mMozSubtreeHiddenOnlyVisually) {
+    // Only descend the visible card of deck / tabpanels
+    return false;
+  }
+  for (nsIFrame* child : aFrame->PrincipalChildList()) {
+    if (MaybeCreateDisplayPortInFirstScrollFrameEncountered(child, aBuilder)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void DisplayPortUtils::ExpireDisplayPortOnAsyncScrollableAncestor(
+    nsIFrame* aFrame) {
+  nsIFrame* frame = aFrame;
+  while (frame) {
+    frame = nsLayoutUtils::GetCrossDocParentFrameInProcess(frame);
+    if (!frame) {
+      break;
+    }
+    nsIScrollableFrame* scrollAncestor =
+        nsLayoutUtils::GetAsyncScrollableAncestorFrame(frame);
+    if (!scrollAncestor) {
+      break;
+    }
+    frame = do_QueryFrame(scrollAncestor);
+    MOZ_ASSERT(frame);
+    if (!frame) {
+      break;
+    }
+    MOZ_ASSERT(scrollAncestor->WantAsyncScroll() ||
+               frame->PresShell()->GetRootScrollFrame() == frame);
+    if (HasDisplayPort(frame->GetContent())) {
+      scrollAncestor->TriggerDisplayPortExpiration();
+      // Stop after the first trigger. If it failed, there's no point in
+      // continuing because all the rest of the frames we encounter are going
+      // to be ancestors of |scrollAncestor| which will keep its displayport.
+      // If the trigger succeeded, we stop because when the trigger executes
+      // it will call this function again to trigger the next ancestor up the
+      // chain.
+      break;
+    }
+  }
+}
+
+Maybe<nsRect> DisplayPortUtils::GetRootDisplayportBase(PresShell* aPresShell) {
+  DebugOnly<nsPresContext*> pc = aPresShell->GetPresContext();
+  MOZ_ASSERT(pc, "this function should be called after PresShell::Init");
+  MOZ_ASSERT(pc->IsRootContentDocumentCrossProcess() ||
+             !pc->GetParentPresContext());
+
+  dom::BrowserChild* browserChild = dom::BrowserChild::GetFrom(aPresShell);
+  if (browserChild && !browserChild->IsTopLevel()) {
+    // If this is an in-process root in on OOP iframe, use the visible rect if
+    // it's been set.
+    return browserChild->GetVisibleRect();
+  }
+
+  nsIFrame* frame = aPresShell->GetRootScrollFrame();
+  if (!frame) {
+    frame = aPresShell->GetRootFrame();
+  }
+
+  nsRect baseRect;
+  if (frame) {
+    baseRect = nsRect(nsPoint(0, 0),
+                      nsLayoutUtils::CalculateCompositionSizeForFrame(frame));
+  } else {
+    baseRect = nsRect(nsPoint(0, 0),
+                      aPresShell->GetPresContext()->GetVisibleArea().Size());
+  }
+
+  return Some(baseRect);
+}
+
+}  // namespace mozilla