Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 1652 insertions, 0 deletions

diff --git a/layout/xul/nsSliderFrame.cpp b/layout/xul/nsSliderFrame.cpp
new file mode 100644
index 0000000000..6d26f76035
--- /dev/null
+++ b/layout/xul/nsSliderFrame.cpp
@@ -0,0 +1,1652 @@
+/* -*- 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/. */
+
+//
+// Eric Vaughan
+// Netscape Communications
+//
+// See documentation in associated header file
+//
+
+#include "nsSliderFrame.h"
+
+#include "mozilla/ComputedStyle.h"
+#include "nsPresContext.h"
+#include "nsIContent.h"
+#include "nsCOMPtr.h"
+#include "nsNameSpaceManager.h"
+#include "nsGkAtoms.h"
+#include "nsHTMLParts.h"
+#include "nsCSSRendering.h"
+#include "nsScrollbarButtonFrame.h"
+#include "nsIScrollableFrame.h"
+#include "nsIScrollbarMediator.h"
+#include "nsISupportsImpl.h"
+#include "nsScrollbarFrame.h"
+#include "nsRepeatService.h"
+#include "nsContentUtils.h"
+#include "nsLayoutUtils.h"
+#include "nsDisplayList.h"
+#include "nsDeviceContext.h"
+#include "nsRefreshDriver.h"     // for nsAPostRefreshObserver
+#include "mozilla/Assertions.h"  // for MOZ_ASSERT
+#include "mozilla/DisplayPortUtils.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_general.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/SVGIntegrationUtils.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/layers/APZCCallbackHelper.h"
+#include "mozilla/layers/AsyncDragMetrics.h"
+#include "mozilla/layers/InputAPZContext.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+#include "mozilla/StaticPrefs_slider.h"
+#include <algorithm>
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+using mozilla::dom::Document;
+using mozilla::dom::Event;
+using mozilla::layers::AsyncDragMetrics;
+using mozilla::layers::InputAPZContext;
+using mozilla::layers::ScrollbarData;
+using mozilla::layers::ScrollDirection;
+
+bool nsSliderFrame::gMiddlePref = false;
+
+// Turn this on if you want to debug slider frames.
+#undef DEBUG_SLIDER
+
+nsIFrame* NS_NewSliderFrame(PresShell* aPresShell, ComputedStyle* aStyle) {
+  return new (aPresShell) nsSliderFrame(aStyle, aPresShell->GetPresContext());
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsSliderFrame)
+
+NS_QUERYFRAME_HEAD(nsSliderFrame)
+  NS_QUERYFRAME_ENTRY(nsSliderFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+nsSliderFrame::nsSliderFrame(ComputedStyle* aStyle, nsPresContext* aPresContext)
+    : nsContainerFrame(aStyle, aPresContext, kClassID),
+      mRatio(0.0f),
+      mDragStart(0),
+      mThumbStart(0),
+      mCurPos(0),
+      mRepeatDirection(0),
+      mDragFinished(true),
+      mUserChanged(false),
+      mScrollingWithAPZ(false),
+      mSuppressionActive(false),
+      mThumbMinLength(0) {}
+
+// stop timer
+nsSliderFrame::~nsSliderFrame() {
+  if (mSuppressionActive) {
+    if (auto* presShell = PresShell()) {
+      presShell->SuppressDisplayport(false);
+    }
+  }
+}
+
+void nsSliderFrame::Init(nsIContent* aContent, nsContainerFrame* aParent,
+                         nsIFrame* aPrevInFlow) {
+  nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
+
+  static bool gotPrefs = false;
+  if (!gotPrefs) {
+    gotPrefs = true;
+
+    gMiddlePref = Preferences::GetBool("middlemouse.scrollbarPosition");
+  }
+
+  mCurPos = GetCurrentPosition(aContent);
+}
+
+void nsSliderFrame::RemoveFrame(DestroyContext& aContext, ChildListID aListID,
+                                nsIFrame* aOldFrame) {
+  nsContainerFrame::RemoveFrame(aContext, aListID, aOldFrame);
+  if (mFrames.IsEmpty()) {
+    RemoveListener();
+  }
+}
+
+void nsSliderFrame::InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame,
+                                 const nsLineList::iterator* aPrevFrameLine,
+                                 nsFrameList&& aFrameList) {
+  bool wasEmpty = mFrames.IsEmpty();
+  nsContainerFrame::InsertFrames(aListID, aPrevFrame, aPrevFrameLine,
+                                 std::move(aFrameList));
+  if (wasEmpty) {
+    AddListener();
+  }
+}
+
+void nsSliderFrame::AppendFrames(ChildListID aListID,
+                                 nsFrameList&& aFrameList) {
+  // If we have no children and on was added then make sure we add the
+  // listener
+  bool wasEmpty = mFrames.IsEmpty();
+  nsContainerFrame::AppendFrames(aListID, std::move(aFrameList));
+  if (wasEmpty) {
+    AddListener();
+  }
+}
+
+int32_t nsSliderFrame::GetCurrentPosition(nsIContent* content) {
+  return GetIntegerAttribute(content, nsGkAtoms::curpos, 0);
+}
+
+int32_t nsSliderFrame::GetMinPosition(nsIContent* content) {
+  return GetIntegerAttribute(content, nsGkAtoms::minpos, 0);
+}
+
+int32_t nsSliderFrame::GetMaxPosition(nsIContent* content) {
+  return GetIntegerAttribute(content, nsGkAtoms::maxpos, 100);
+}
+
+int32_t nsSliderFrame::GetIncrement(nsIContent* content) {
+  return GetIntegerAttribute(content, nsGkAtoms::increment, 1);
+}
+
+int32_t nsSliderFrame::GetPageIncrement(nsIContent* content) {
+  return GetIntegerAttribute(content, nsGkAtoms::pageincrement, 10);
+}
+
+int32_t nsSliderFrame::GetIntegerAttribute(nsIContent* content, nsAtom* atom,
+                                           int32_t defaultValue) {
+  nsAutoString value;
+  if (content->IsElement()) {
+    content->AsElement()->GetAttr(atom, value);
+  }
+  if (!value.IsEmpty()) {
+    nsresult error;
+
+    // convert it to an integer
+    defaultValue = value.ToInteger(&error);
+  }
+
+  return defaultValue;
+}
+
+nsresult nsSliderFrame::AttributeChanged(int32_t aNameSpaceID,
+                                         nsAtom* aAttribute, int32_t aModType) {
+  nsresult rv =
+      nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType);
+  // if the current position changes
+  if (aAttribute == nsGkAtoms::curpos) {
+    CurrentPositionChanged();
+  } else if (aAttribute == nsGkAtoms::minpos ||
+             aAttribute == nsGkAtoms::maxpos) {
+    // bounds check it.
+
+    nsScrollbarFrame* scrollbarBox = Scrollbar();
+    nsCOMPtr<nsIContent> scrollbar = scrollbarBox->GetContent();
+    int32_t current = GetCurrentPosition(scrollbar);
+    int32_t min = GetMinPosition(scrollbar);
+    int32_t max = GetMaxPosition(scrollbar);
+
+    if (current < min || current > max) {
+      int32_t direction = 0;
+      if (current < min || max < min) {
+        current = min;
+        direction = -1;
+      } else if (current > max) {
+        current = max;
+        direction = 1;
+      }
+
+      // set the new position and notify observers
+      nsIScrollbarMediator* mediator = scrollbarBox->GetScrollbarMediator();
+      scrollbarBox->SetIncrementToWhole(direction);
+      if (mediator) {
+        mediator->ScrollByWhole(scrollbarBox, direction,
+                                ScrollSnapFlags::IntendedEndPosition);
+      }
+      // 'this' might be destroyed here
+
+      nsContentUtils::AddScriptRunner(new nsSetAttrRunnable(
+          scrollbar->AsElement(), nsGkAtoms::curpos, current));
+    }
+  }
+
+  if (aAttribute == nsGkAtoms::minpos || aAttribute == nsGkAtoms::maxpos ||
+      aAttribute == nsGkAtoms::pageincrement ||
+      aAttribute == nsGkAtoms::increment) {
+    PresShell()->FrameNeedsReflow(
+        this, IntrinsicDirty::FrameAncestorsAndDescendants, NS_FRAME_IS_DIRTY);
+  }
+
+  return rv;
+}
+
+namespace mozilla {
+
+// Draw any tick marks that show the position of find in page results.
+class nsDisplaySliderMarks final : public nsPaintedDisplayItem {
+ public:
+  nsDisplaySliderMarks(nsDisplayListBuilder* aBuilder, nsSliderFrame* aFrame)
+      : nsPaintedDisplayItem(aBuilder, aFrame) {
+    MOZ_COUNT_CTOR(nsDisplaySliderMarks);
+  }
+  MOZ_COUNTED_DTOR_OVERRIDE(nsDisplaySliderMarks)
+
+  NS_DISPLAY_DECL_NAME("SliderMarks", TYPE_SLIDER_MARKS)
+
+  void PaintMarks(nsDisplayListBuilder* aDisplayListBuilder,
+                  wr::DisplayListBuilder* aBuilder, gfxContext* aCtx);
+
+  nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) const override {
+    *aSnap = false;
+    return mFrame->InkOverflowRectRelativeToSelf() + ToReferenceFrame();
+  }
+
+  bool CreateWebRenderCommands(
+      wr::DisplayListBuilder& aBuilder, wr::IpcResourceUpdateQueue& aResources,
+      const StackingContextHelper& aSc,
+      layers::RenderRootStateManager* aManager,
+      nsDisplayListBuilder* aDisplayListBuilder) override;
+
+  void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
+};
+
+// This is shared between the webrender and Paint() paths. For the former,
+// aBuilder should be assigned and aCtx will be null. For the latter, aBuilder
+// should be null and aCtx should be the gfxContext for painting.
+void nsDisplaySliderMarks::PaintMarks(nsDisplayListBuilder* aDisplayListBuilder,
+                                      wr::DisplayListBuilder* aBuilder,
+                                      gfxContext* aCtx) {
+  DrawTarget* drawTarget = nullptr;
+  if (aCtx) {
+    drawTarget = aCtx->GetDrawTarget();
+  } else {
+    MOZ_ASSERT(aBuilder);
+  }
+
+  Document* doc = mFrame->GetContent()->GetUncomposedDoc();
+  if (!doc) {
+    return;
+  }
+
+  nsGlobalWindowInner* window =
+      nsGlobalWindowInner::Cast(doc->GetInnerWindow());
+  if (!window) {
+    return;
+  }
+
+  nsSliderFrame* sliderFrame = static_cast<nsSliderFrame*>(mFrame);
+
+  nsIFrame* scrollbarBox = sliderFrame->Scrollbar();
+  nsCOMPtr<nsIContent> scrollbar = scrollbarBox->GetContent();
+
+  int32_t minPos = sliderFrame->GetMinPosition(scrollbar);
+  int32_t maxPos = sliderFrame->GetMaxPosition(scrollbar);
+
+  // Use the text highlight color for the tick marks.
+  nscolor highlightColor =
+      LookAndFeel::Color(LookAndFeel::ColorID::TextHighlightBackground, mFrame);
+  DeviceColor fillColor = ToDeviceColor(highlightColor);
+  fillColor.a = 0.3;  // make the mark mostly transparent
+
+  int32_t appUnitsPerDevPixel =
+      sliderFrame->PresContext()->AppUnitsPerDevPixel();
+  nsRect sliderRect = sliderFrame->GetRect();
+
+  nsPoint refPoint = aDisplayListBuilder->ToReferenceFrame(mFrame);
+
+  // Increase the height of the tick mark rectangle by one pixel. If the
+  // desktop scale is greater than 1, it should be increased more.
+  // The tick marks should be drawn ignoring any page zoom that is applied.
+  float increasePixels = sliderFrame->PresContext()
+                             ->DeviceContext()
+                             ->GetDesktopToDeviceScale()
+                             .scale;
+  const bool isHorizontal = sliderFrame->Scrollbar()->IsHorizontal();
+  float increasePixelsX = isHorizontal ? increasePixels : 0;
+  float increasePixelsY = isHorizontal ? 0 : increasePixels;
+  nsSize initialSize =
+      isHorizontal ? nsSize(0, sliderRect.height) : nsSize(sliderRect.width, 0);
+
+  nsTArray<uint32_t>& marks = window->GetScrollMarks();
+  for (uint32_t m = 0; m < marks.Length(); m++) {
+    uint32_t markValue = marks[m];
+    if (markValue > (uint32_t)maxPos) {
+      markValue = maxPos;
+    }
+    if (markValue < (uint32_t)minPos) {
+      markValue = minPos;
+    }
+
+    // The values in the marks array range up to the window's
+    // scrollMax{X,Y} - scrollMin{X,Y} (the same as the slider's maxpos).
+    // Scale the values to fit within the slider's width or height.
+    nsRect markRect(refPoint, initialSize);
+    if (isHorizontal) {
+      markRect.x +=
+          (nscoord)((double)markValue / (maxPos - minPos) * sliderRect.width);
+    } else {
+      markRect.y +=
+          (nscoord)((double)markValue / (maxPos - minPos) * sliderRect.height);
+    }
+
+    if (drawTarget) {
+      Rect devPixelRect =
+          NSRectToSnappedRect(markRect, appUnitsPerDevPixel, *drawTarget);
+      devPixelRect.Inflate(increasePixelsX, increasePixelsY);
+      drawTarget->FillRect(devPixelRect, ColorPattern(fillColor));
+    } else {
+      LayoutDeviceIntRect dRect = LayoutDeviceIntRect::FromAppUnitsToNearest(
+          markRect, appUnitsPerDevPixel);
+      dRect.Inflate(increasePixelsX, increasePixelsY);
+      wr::LayoutRect layoutRect = wr::ToLayoutRect(dRect);
+      aBuilder->PushRect(layoutRect, layoutRect, BackfaceIsHidden(), false,
+                         false, wr::ToColorF(fillColor));
+    }
+  }
+}
+
+bool nsDisplaySliderMarks::CreateWebRenderCommands(
+    wr::DisplayListBuilder& aBuilder, wr::IpcResourceUpdateQueue& aResources,
+    const StackingContextHelper& aSc, layers::RenderRootStateManager* aManager,
+    nsDisplayListBuilder* aDisplayListBuilder) {
+  PaintMarks(aDisplayListBuilder, &aBuilder, nullptr);
+  return true;
+}
+
+void nsDisplaySliderMarks::Paint(nsDisplayListBuilder* aBuilder,
+                                 gfxContext* aCtx) {
+  PaintMarks(aBuilder, nullptr, aCtx);
+}
+
+}  // namespace mozilla
+
+void nsSliderFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+                                     const nsDisplayListSet& aLists) {
+  if (aBuilder->IsForEventDelivery() && isDraggingThumb()) {
+    // This is EVIL, we shouldn't be messing with event delivery just to get
+    // thumb mouse drag events to arrive at the slider!
+    aLists.Outlines()->AppendNewToTop<nsDisplayEventReceiver>(aBuilder, this);
+    return;
+  }
+
+  DisplayBorderBackgroundOutline(aBuilder, aLists);
+
+  if (nsIFrame* thumb = mFrames.FirstChild()) {
+    BuildDisplayListForThumb(aBuilder, thumb, aLists);
+  }
+
+  // If this is an scrollbar for the root frame, draw any markers.
+  // Markers are not drawn for other scrollbars.
+  // XXX seems like this should be done in nsScrollbarFrame instead perhaps?
+  if (!aBuilder->IsForEventDelivery()) {
+    nsScrollbarFrame* scrollbar = Scrollbar();
+    if (nsIScrollableFrame* scrollFrame =
+            do_QueryFrame(scrollbar->GetParent())) {
+      if (scrollFrame->IsRootScrollFrameOfDocument()) {
+        nsGlobalWindowInner* window = nsGlobalWindowInner::Cast(
+            PresContext()->Document()->GetInnerWindow());
+        if (window &&
+            window->GetScrollMarksOnHScrollbar() == scrollbar->IsHorizontal() &&
+            window->GetScrollMarks().Length() > 0) {
+          aLists.Content()->AppendNewToTop<nsDisplaySliderMarks>(aBuilder,
+                                                                 this);
+        }
+      }
+    }
+  }
+}
+
+static bool UsesCustomScrollbarMediator(nsIFrame* scrollbarBox) {
+  if (nsScrollbarFrame* scrollbarFrame = do_QueryFrame(scrollbarBox)) {
+    if (nsIScrollbarMediator* mediator =
+            scrollbarFrame->GetScrollbarMediator()) {
+      nsIScrollableFrame* scrollFrame = do_QueryFrame(mediator);
+      // The scrollbar mediator is not the scroll frame.
+      // That means this scroll frame has a custom scrollbar mediator.
+      if (!scrollFrame) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void nsSliderFrame::BuildDisplayListForThumb(nsDisplayListBuilder* aBuilder,
+                                             nsIFrame* aThumb,
+                                             const nsDisplayListSet& aLists) {
+  nsRect thumbRect(aThumb->GetRect());
+
+  nsRect sliderTrack = GetRect();
+  if (sliderTrack.width < thumbRect.width ||
+      sliderTrack.height < thumbRect.height) {
+    return;
+  }
+
+  // If this scrollbar is the scrollbar of an actively scrolled scroll frame,
+  // layerize the scrollbar thumb, wrap it in its own ContainerLayer and
+  // attach scrolling information to it.
+  // We do this here and not in the thumb's BuildDisplayList so that the event
+  // region that gets created for the thumb is included in the nsDisplayOwnLayer
+  // contents.
+
+  const layers::ScrollableLayerGuid::ViewID scrollTargetId =
+      aBuilder->GetCurrentScrollbarTarget();
+  const bool thumbGetsLayer =
+      scrollTargetId != layers::ScrollableLayerGuid::NULL_SCROLL_ID;
+
+  if (thumbGetsLayer) {
+    const Maybe<ScrollDirection> scrollDirection =
+        aBuilder->GetCurrentScrollbarDirection();
+    MOZ_ASSERT(scrollDirection.isSome());
+    const bool isHorizontal = *scrollDirection == ScrollDirection::eHorizontal;
+    const OuterCSSCoord thumbLength = OuterCSSPixel::FromAppUnits(
+        isHorizontal ? thumbRect.width : thumbRect.height);
+    const OuterCSSCoord minThumbLength =
+        OuterCSSPixel::FromAppUnits(mThumbMinLength);
+
+    nsIFrame* scrollbarBox = Scrollbar();
+    bool isAsyncDraggable = !UsesCustomScrollbarMediator(scrollbarBox);
+
+    nsPoint scrollPortOrigin;
+    if (nsIScrollableFrame* scrollFrame =
+            do_QueryFrame(scrollbarBox->GetParent())) {
+      scrollPortOrigin = scrollFrame->GetScrollPortRect().TopLeft();
+    } else {
+      isAsyncDraggable = false;
+    }
+
+    // This rect is the range in which the scroll thumb can slide in.
+    sliderTrack = sliderTrack + scrollbarBox->GetPosition() - scrollPortOrigin;
+    const OuterCSSCoord sliderTrackStart = OuterCSSPixel::FromAppUnits(
+        isHorizontal ? sliderTrack.x : sliderTrack.y);
+    const OuterCSSCoord sliderTrackLength = OuterCSSPixel::FromAppUnits(
+        isHorizontal ? sliderTrack.width : sliderTrack.height);
+    const OuterCSSCoord thumbStart =
+        OuterCSSPixel::FromAppUnits(isHorizontal ? thumbRect.x : thumbRect.y);
+
+    const nsRect overflow = aThumb->InkOverflowRectRelativeToParent();
+    nsSize refSize = aBuilder->RootReferenceFrame()->GetSize();
+    nsRect dirty = aBuilder->GetVisibleRect().Intersect(thumbRect);
+    dirty = nsLayoutUtils::ComputePartialPrerenderArea(
+        aThumb, aBuilder->GetVisibleRect(), overflow, refSize);
+
+    nsDisplayListBuilder::AutoBuildingDisplayList buildingDisplayList(
+        aBuilder, this, dirty, dirty);
+
+    // Clip the thumb layer to the slider track. This is necessary to ensure
+    // FrameLayerBuilder is able to merge content before and after the
+    // scrollframe into the same layer (otherwise it thinks the thumb could
+    // potentially move anywhere within the existing clip).
+    DisplayListClipState::AutoSaveRestore thumbClipState(aBuilder);
+    thumbClipState.ClipContainingBlockDescendants(
+        GetRectRelativeToSelf() + aBuilder->ToReferenceFrame(this));
+
+    // Have the thumb's container layer capture the current clip, so
+    // it doesn't apply to the thumb's contents. This allows the contents
+    // to be fully rendered even if they're partially or fully offscreen,
+    // so async scrolling can still bring it into view.
+    DisplayListClipState::AutoSaveRestore thumbContentsClipState(aBuilder);
+    thumbContentsClipState.Clear();
+
+    nsDisplayListBuilder::AutoContainerASRTracker contASRTracker(aBuilder);
+    nsDisplayListCollection tempLists(aBuilder);
+    BuildDisplayListForChild(aBuilder, aThumb, tempLists);
+
+    // This is a bit of a hack. Collect up all descendant display items
+    // and merge them into a single Content() list.
+    nsDisplayList masterList(aBuilder);
+    masterList.AppendToTop(tempLists.BorderBackground());
+    masterList.AppendToTop(tempLists.BlockBorderBackgrounds());
+    masterList.AppendToTop(tempLists.Floats());
+    masterList.AppendToTop(tempLists.Content());
+    masterList.AppendToTop(tempLists.PositionedDescendants());
+    masterList.AppendToTop(tempLists.Outlines());
+
+    // Restore the saved clip so it applies to the thumb container layer.
+    thumbContentsClipState.Restore();
+
+    // Wrap the list to make it its own layer.
+    const ActiveScrolledRoot* ownLayerASR = contASRTracker.GetContainerASR();
+    aLists.Content()->AppendNewToTopWithIndex<nsDisplayOwnLayer>(
+        aBuilder, this,
+        /* aIndex = */ nsDisplayOwnLayer::OwnLayerForScrollThumb, &masterList,
+        ownLayerASR, nsDisplayOwnLayerFlags::None,
+        ScrollbarData::CreateForThumb(*scrollDirection, GetThumbRatio(),
+                                      thumbStart, thumbLength, minThumbLength,
+                                      isAsyncDraggable, sliderTrackStart,
+                                      sliderTrackLength, scrollTargetId),
+        true, false);
+
+    return;
+  }
+
+  BuildDisplayListForChild(aBuilder, aThumb, aLists);
+}
+
+void nsSliderFrame::Reflow(nsPresContext* aPresContext,
+                           ReflowOutput& aDesiredSize,
+                           const ReflowInput& aReflowInput,
+                           nsReflowStatus& aStatus) {
+  MarkInReflow();
+  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+  NS_ASSERTION(aReflowInput.AvailableWidth() != NS_UNCONSTRAINEDSIZE,
+               "Bogus avail width");
+  NS_ASSERTION(aReflowInput.AvailableHeight() != NS_UNCONSTRAINEDSIZE,
+               "Bogus avail height");
+
+  const auto wm = GetWritingMode();
+
+  // We always take all the space we're given.
+  aDesiredSize.SetSize(wm, aReflowInput.ComputedSize(wm));
+  aDesiredSize.SetOverflowAreasToDesiredBounds();
+
+  // Get the thumb, should be our only child.
+  nsIFrame* thumbBox = mFrames.FirstChild();
+  if (NS_WARN_IF(!thumbBox)) {
+    return;
+  }
+
+  nsScrollbarFrame* scrollbarBox = Scrollbar();
+  nsIContent* scrollbar = scrollbarBox->GetContent();
+  const bool horizontal = scrollbarBox->IsHorizontal();
+  nsSize availSize = aDesiredSize.PhysicalSize();
+  ReflowInput thumbRI(aPresContext, aReflowInput, thumbBox,
+                      aReflowInput.AvailableSize(wm));
+
+  // Get the thumb's pref size.
+  nsSize thumbSize = thumbRI.ComputedMinSize(wm).GetPhysicalSize(wm);
+  if (horizontal) {
+    thumbSize.height = availSize.height;
+  } else {
+    thumbSize.width = availSize.width;
+  }
+
+  int32_t curPos = GetCurrentPosition(scrollbar);
+  int32_t minPos = GetMinPosition(scrollbar);
+  int32_t maxPos = GetMaxPosition(scrollbar);
+  int32_t pageIncrement = GetPageIncrement(scrollbar);
+
+  maxPos = std::max(minPos, maxPos);
+  curPos = clamped(curPos, minPos, maxPos);
+
+  // If modifying the logic here, be sure to modify the corresponding
+  // compositor-side calculation in ScrollThumbUtils::ApplyTransformForAxis().
+  nscoord& availableLength = horizontal ? availSize.width : availSize.height;
+  nscoord& thumbLength = horizontal ? thumbSize.width : thumbSize.height;
+  mThumbMinLength = thumbLength;
+
+  if ((pageIncrement + maxPos - minPos) > 0) {
+    float ratio = float(pageIncrement) / float(maxPos - minPos + pageIncrement);
+    thumbLength =
+        std::max(thumbLength, NSToCoordRound(availableLength * ratio));
+  }
+
+  // Round the thumb's length to device pixels.
+  nsPresContext* presContext = PresContext();
+  thumbLength = presContext->DevPixelsToAppUnits(
+      presContext->AppUnitsToDevPixels(thumbLength));
+
+  // mRatio translates the thumb position in app units to the value.
+  mRatio = (minPos != maxPos)
+               ? float(availableLength - thumbLength) / float(maxPos - minPos)
+               : 1;
+
+  // in reverse mode, curpos is reversed such that lower values are to the
+  // right or bottom and increase leftwards or upwards. In this case, use the
+  // offset from the end instead of the beginning.
+  bool reverse = mContent->AsElement()->AttrValueIs(
+      kNameSpaceID_None, nsGkAtoms::dir, nsGkAtoms::reverse, eCaseMatters);
+  nscoord pos = reverse ? (maxPos - curPos) : (curPos - minPos);
+
+  // set the thumb's coord to be the current pos * the ratio.
+  nsPoint thumbPos;
+  if (horizontal) {
+    thumbPos.x = NSToCoordRound(pos * mRatio);
+  } else {
+    thumbPos.y = NSToCoordRound(pos * mRatio);
+  }
+
+  // Same to `snappedThumbLocation` in `nsSliderFrame::CurrentPositionChanged`,
+  // to avoid putting the scroll thumb at subpixel positions which cause
+  // needless invalidations
+  nscoord appUnitsPerPixel = PresContext()->AppUnitsPerDevPixel();
+  thumbPos =
+      ToAppUnits(thumbPos.ToNearestPixels(appUnitsPerPixel), appUnitsPerPixel);
+
+  const LogicalPoint logicalPos(wm, thumbPos, availSize);
+  // TODO: It seems like a lot of this stuff should really belong in the thumb's
+  // reflow code rather than here, but since we rely on the frame tree structure
+  // heavily this matches the previous code more closely for now.
+  ReflowOutput thumbDesiredSize(wm);
+  const auto flags = ReflowChildFlags::Default;
+  nsReflowStatus status;
+  thumbRI.SetComputedISize(thumbSize.width);
+  thumbRI.SetComputedBSize(thumbSize.height);
+  ReflowChild(thumbBox, aPresContext, thumbDesiredSize, thumbRI, wm, logicalPos,
+              availSize, flags, status);
+  FinishReflowChild(thumbBox, aPresContext, thumbDesiredSize, &thumbRI, wm,
+                    logicalPos, availSize, flags);
+}
+
+nsresult nsSliderFrame::HandleEvent(nsPresContext* aPresContext,
+                                    WidgetGUIEvent* aEvent,
+                                    nsEventStatus* aEventStatus) {
+  NS_ENSURE_ARG_POINTER(aEventStatus);
+
+  if (mAPZDragInitiated &&
+      *mAPZDragInitiated == InputAPZContext::GetInputBlockId() &&
+      aEvent->mMessage == eMouseDown) {
+    // If we get the mousedown after the APZ notification, then immediately
+    // switch into the state corresponding to an APZ thumb-drag. Note that
+    // we can't just do this in AsyncScrollbarDragInitiated() directly because
+    // the handling for this mousedown event in the presShell will reset the
+    // capturing content which makes isDraggingThumb() return false. We check
+    // the input block here to make sure that we correctly handle any ordering
+    // of {eMouseDown arriving, AsyncScrollbarDragInitiated() being called}.
+    mAPZDragInitiated = Nothing();
+    DragThumb(true);
+    mScrollingWithAPZ = true;
+    return NS_OK;
+  }
+
+  // If a web page calls event.preventDefault() we still want to
+  // scroll when scroll arrow is clicked. See bug 511075.
+  if (!mContent->IsInNativeAnonymousSubtree() &&
+      nsEventStatus_eConsumeNoDefault == *aEventStatus) {
+    return NS_OK;
+  }
+
+  if (!mDragFinished && !isDraggingThumb()) {
+    StopDrag();
+    return NS_OK;
+  }
+
+  nsScrollbarFrame* scrollbarBox = Scrollbar();
+  nsCOMPtr<nsIContent> scrollbar = scrollbarBox->GetContent();
+  bool isHorizontal = scrollbarBox->IsHorizontal();
+
+  if (isDraggingThumb()) {
+    switch (aEvent->mMessage) {
+      case eTouchMove:
+      case eMouseMove: {
+        if (mScrollingWithAPZ) {
+          break;
+        }
+        nsPoint eventPoint;
+        if (!GetEventPoint(aEvent, eventPoint)) {
+          break;
+        }
+        if (mRepeatDirection) {
+          // On Linux the destination point is determined by the initial click
+          // on the scrollbar track and doesn't change until the mouse button
+          // is released.
+#ifndef MOZ_WIDGET_GTK
+          // On the other platforms we need to update the destination point now.
+          mDestinationPoint = eventPoint;
+          StopRepeat();
+          StartRepeat();
+#endif
+          break;
+        }
+
+        nscoord pos = isHorizontal ? eventPoint.x : eventPoint.y;
+
+        nsIFrame* thumbFrame = mFrames.FirstChild();
+        if (!thumbFrame) {
+          return NS_OK;
+        }
+
+        // take our current position and subtract the start location
+        pos -= mDragStart;
+        bool isMouseOutsideThumb = false;
+        const int32_t snapMultiplier = StaticPrefs::slider_snapMultiplier();
+        if (snapMultiplier) {
+          nsSize thumbSize = thumbFrame->GetSize();
+          if (isHorizontal) {
+            // horizontal scrollbar - check if mouse is above or below thumb
+            // XXXbz what about looking at the .y of the thumb's rect?  Is that
+            // always zero here?
+            if (eventPoint.y < -snapMultiplier * thumbSize.height ||
+                eventPoint.y >
+                    thumbSize.height + snapMultiplier * thumbSize.height) {
+              isMouseOutsideThumb = true;
+            }
+          } else {
+            // vertical scrollbar - check if mouse is left or right of thumb
+            if (eventPoint.x < -snapMultiplier * thumbSize.width ||
+                eventPoint.x >
+                    thumbSize.width + snapMultiplier * thumbSize.width) {
+              isMouseOutsideThumb = true;
+            }
+          }
+        }
+        if (aEvent->mClass == eTouchEventClass) {
+          *aEventStatus = nsEventStatus_eConsumeNoDefault;
+        }
+        if (isMouseOutsideThumb) {
+          SetCurrentThumbPosition(scrollbar, mThumbStart, false, false);
+          return NS_OK;
+        }
+
+        // set it
+        SetCurrentThumbPosition(scrollbar, pos, false, true);  // with snapping
+      } break;
+
+      case eTouchEnd:
+      case eMouseUp:
+        if (ShouldScrollForEvent(aEvent)) {
+          StopDrag();
+          // we MUST call nsFrame HandleEvent for mouse ups to maintain the
+          // selection state and capture state.
+          return nsIFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
+        }
+        break;
+
+      default:
+        break;
+    }
+
+    // return nsIFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
+    return NS_OK;
+  }
+
+  if (ShouldScrollToClickForEvent(aEvent)) {
+    nsPoint eventPoint;
+    if (!GetEventPoint(aEvent, eventPoint)) {
+      return NS_OK;
+    }
+    nscoord pos = isHorizontal ? eventPoint.x : eventPoint.y;
+
+    // adjust so that the middle of the thumb is placed under the click
+    nsIFrame* thumbFrame = mFrames.FirstChild();
+    if (!thumbFrame) {
+      return NS_OK;
+    }
+    nsSize thumbSize = thumbFrame->GetSize();
+    nscoord thumbLength = isHorizontal ? thumbSize.width : thumbSize.height;
+
+    // set it
+    AutoWeakFrame weakFrame(this);
+    // should aMaySnap be true here?
+    SetCurrentThumbPosition(scrollbar, pos - thumbLength / 2, false, false);
+    NS_ENSURE_TRUE(weakFrame.IsAlive(), NS_OK);
+
+    DragThumb(true);
+
+    if (aEvent->mClass == eTouchEventClass) {
+      *aEventStatus = nsEventStatus_eConsumeNoDefault;
+    }
+
+    SetupDrag(aEvent, thumbFrame, pos, isHorizontal);
+  }
+#ifdef MOZ_WIDGET_GTK
+  else if (ShouldScrollForEvent(aEvent) && aEvent->mClass == eMouseEventClass &&
+           aEvent->AsMouseEvent()->mButton == MouseButton::eSecondary) {
+    // HandlePress and HandleRelease are usually called via
+    // nsIFrame::HandleEvent, but only for the left mouse button.
+    if (aEvent->mMessage == eMouseDown) {
+      HandlePress(aPresContext, aEvent, aEventStatus);
+    } else if (aEvent->mMessage == eMouseUp) {
+      HandleRelease(aPresContext, aEvent, aEventStatus);
+    }
+
+    return NS_OK;
+  }
+#endif
+
+  // XXX hack until handle release is actually called in nsframe.
+  //  if (aEvent->mMessage == eMouseOut ||
+  //      aEvent->mMessage == NS_MOUSE_RIGHT_BUTTON_UP ||
+  //      aEvent->mMessage == NS_MOUSE_LEFT_BUTTON_UP) {
+  //    HandleRelease(aPresContext, aEvent, aEventStatus);
+  //  }
+
+  if (aEvent->mMessage == eMouseOut && mRepeatDirection) {
+    HandleRelease(aPresContext, aEvent, aEventStatus);
+  }
+
+  return nsIFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
+}
+
+// Helper function to collect the "scroll to click" metric. Beware of
+// caching this, users expect to be able to change the system preference
+// and see the browser change its behavior immediately.
+bool nsSliderFrame::GetScrollToClick() {
+  return LookAndFeel::GetInt(LookAndFeel::IntID::ScrollToClick, false);
+}
+
+nsScrollbarFrame* nsSliderFrame::Scrollbar() {
+  MOZ_ASSERT(GetParent());
+  MOZ_DIAGNOSTIC_ASSERT(
+      static_cast<nsScrollbarFrame*>(do_QueryFrame(GetParent())));
+  return static_cast<nsScrollbarFrame*>(GetParent());
+}
+
+void nsSliderFrame::PageUpDown(nscoord change) {
+  // on a page up or down get our page increment. We get this by getting the
+  // scrollbar we are in and asking it for the current position and the page
+  // increment. If we are not in a scrollbar we will get the values from our own
+  // node.
+  nsIFrame* scrollbarBox = Scrollbar();
+  nsCOMPtr<nsIContent> scrollbar = scrollbarBox->GetContent();
+
+  nscoord pageIncrement = GetPageIncrement(scrollbar);
+  int32_t curpos = GetCurrentPosition(scrollbar);
+  int32_t minpos = GetMinPosition(scrollbar);
+  int32_t maxpos = GetMaxPosition(scrollbar);
+
+  // get the new position and make sure it is in bounds
+  int32_t newpos = curpos + change * pageIncrement;
+  if (newpos < minpos || maxpos < minpos)
+    newpos = minpos;
+  else if (newpos > maxpos)
+    newpos = maxpos;
+
+  SetCurrentPositionInternal(scrollbar, newpos, true);
+}
+
+// called when the current position changed and we need to update the thumb's
+// location
+void nsSliderFrame::CurrentPositionChanged() {
+  nsScrollbarFrame* scrollbarBox = Scrollbar();
+  nsCOMPtr<nsIContent> scrollbar = scrollbarBox->GetContent();
+
+  // get the current position
+  int32_t curPos = GetCurrentPosition(scrollbar);
+
+  // do nothing if the position did not change
+  if (mCurPos == curPos) {
+    return;
+  }
+
+  // get our current min and max position from our content node
+  int32_t minPos = GetMinPosition(scrollbar);
+  int32_t maxPos = GetMaxPosition(scrollbar);
+
+  maxPos = std::max(minPos, maxPos);
+  curPos = clamped(curPos, minPos, maxPos);
+
+  // get the thumb's rect
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame) {
+    return;
+  }
+
+  bool reverse = mContent->AsElement()->AttrValueIs(
+      kNameSpaceID_None, nsGkAtoms::dir, nsGkAtoms::reverse, eCaseMatters);
+  nscoord pos = reverse ? (maxPos - curPos) : (curPos - minPos);
+  const bool horizontal = Scrollbar()->IsHorizontal();
+
+  // figure out the new rect
+  nsRect thumbRect = thumbFrame->GetRect();
+  nsRect newThumbRect(thumbRect);
+  if (horizontal) {
+    newThumbRect.x = NSToCoordRound(pos * mRatio);
+  } else {
+    newThumbRect.y = NSToCoordRound(pos * mRatio);
+  }
+
+  // avoid putting the scroll thumb at subpixel positions which cause needless
+  // invalidations
+  nscoord appUnitsPerPixel = PresContext()->AppUnitsPerDevPixel();
+  nsPoint snappedThumbLocation =
+      ToAppUnits(newThumbRect.TopLeft().ToNearestPixels(appUnitsPerPixel),
+                 appUnitsPerPixel);
+  if (horizontal) {
+    newThumbRect.x = snappedThumbLocation.x;
+  } else {
+    newThumbRect.y = snappedThumbLocation.y;
+  }
+
+  // set the rect
+  // XXX This out-of-band update of the frame tree is rather fishy!
+  thumbFrame->SetRect(newThumbRect);
+
+  // When the thumb changes position, the mThumbStart value stored in
+  // ScrollbarData for the purpose of telling APZ about the thumb
+  // position painted by the main thread is invalidated. The ScrollbarData
+  // is stored on the nsDisplayOwnLayer item built by *this* frame, so
+  // we need to mark this frame as needing its fisplay item rebuilt.
+  MarkNeedsDisplayItemRebuild();
+
+  // Request a repaint of the scrollbar
+  nsIScrollbarMediator* mediator = scrollbarBox->GetScrollbarMediator();
+  if (!mediator || !mediator->ShouldSuppressScrollbarRepaints()) {
+    SchedulePaint();
+  }
+
+  mCurPos = curPos;
+}
+
+static void UpdateAttribute(dom::Element* aScrollbar, nscoord aNewPos,
+                            bool aNotify, bool aIsSmooth) {
+  nsAutoString str;
+  str.AppendInt(aNewPos);
+
+  if (aIsSmooth) {
+    aScrollbar->SetAttr(kNameSpaceID_None, nsGkAtoms::smooth, u"true"_ns,
+                        false);
+  }
+  aScrollbar->SetAttr(kNameSpaceID_None, nsGkAtoms::curpos, str, aNotify);
+  if (aIsSmooth) {
+    aScrollbar->UnsetAttr(kNameSpaceID_None, nsGkAtoms::smooth, false);
+  }
+}
+
+// Use this function when you want to set the scroll position via the position
+// of the scrollbar thumb, e.g. when dragging the slider. This function scrolls
+// the content in such a way that thumbRect.x/.y becomes aNewThumbPos.
+void nsSliderFrame::SetCurrentThumbPosition(nsIContent* aScrollbar,
+                                            nscoord aNewThumbPos,
+                                            bool aIsSmooth, bool aMaySnap) {
+  int32_t newPos = NSToIntRound(aNewThumbPos / mRatio);
+  if (aMaySnap &&
+      mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::snap,
+                                         nsGkAtoms::_true, eCaseMatters)) {
+    // If snap="true", then the slider may only be set to min + (increment * x).
+    // Otherwise, the slider may be set to any positive integer.
+    int32_t increment = GetIncrement(aScrollbar);
+    newPos = NSToIntRound(newPos / float(increment)) * increment;
+  }
+
+  SetCurrentPosition(aScrollbar, newPos, aIsSmooth);
+}
+
+// Use this function when you know the target scroll position of the scrolled
+// content. aNewPos should be passed to this function as a position as if the
+// minpos is 0. That is, the minpos will be added to the position by this
+// function. In a reverse direction slider, the newpos should be the distance
+// from the end.
+void nsSliderFrame::SetCurrentPosition(nsIContent* aScrollbar, int32_t aNewPos,
+                                       bool aIsSmooth) {
+  // get min and max position from our content node
+  int32_t minpos = GetMinPosition(aScrollbar);
+  int32_t maxpos = GetMaxPosition(aScrollbar);
+
+  // in reverse direction sliders, flip the value so that it goes from
+  // right to left, or bottom to top.
+  if (mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::dir,
+                                         nsGkAtoms::reverse, eCaseMatters)) {
+    aNewPos = maxpos - aNewPos;
+  } else {
+    aNewPos += minpos;
+  }
+
+  // get the new position and make sure it is in bounds
+  if (aNewPos < minpos || maxpos < minpos) {
+    aNewPos = minpos;
+  } else if (aNewPos > maxpos) {
+    aNewPos = maxpos;
+  }
+
+  SetCurrentPositionInternal(aScrollbar, aNewPos, aIsSmooth);
+}
+
+void nsSliderFrame::SetCurrentPositionInternal(nsIContent* aScrollbar,
+                                               int32_t aNewPos,
+                                               bool aIsSmooth) {
+  nsCOMPtr<nsIContent> scrollbar = aScrollbar;
+  nsScrollbarFrame* scrollbarBox = Scrollbar();
+  AutoWeakFrame weakFrame(this);
+
+  mUserChanged = true;
+
+  // See if we have a mediator.
+  if (nsIScrollbarMediator* mediator = scrollbarBox->GetScrollbarMediator()) {
+    nscoord oldPos =
+        nsPresContext::CSSPixelsToAppUnits(GetCurrentPosition(scrollbar));
+    nscoord newPos = nsPresContext::CSSPixelsToAppUnits(aNewPos);
+    mediator->ThumbMoved(scrollbarBox, oldPos, newPos);
+    if (!weakFrame.IsAlive()) {
+      return;
+    }
+    UpdateAttribute(scrollbar->AsElement(), aNewPos, /* aNotify */ false,
+                    aIsSmooth);
+    CurrentPositionChanged();
+    mUserChanged = false;
+    return;
+  }
+
+  UpdateAttribute(scrollbar->AsElement(), aNewPos, true, aIsSmooth);
+  if (!weakFrame.IsAlive()) {
+    return;
+  }
+  mUserChanged = false;
+
+#ifdef DEBUG_SLIDER
+  printf("Current Pos=%d\n", aNewPos);
+#endif
+}
+
+void nsSliderFrame::SetInitialChildList(ChildListID aListID,
+                                        nsFrameList&& aChildList) {
+  nsContainerFrame::SetInitialChildList(aListID, std::move(aChildList));
+  if (aListID == FrameChildListID::Principal) {
+    AddListener();
+  }
+}
+
+nsresult nsSliderMediator::HandleEvent(dom::Event* aEvent) {
+  // Only process the event if the thumb is not being dragged.
+  if (mSlider && !mSlider->isDraggingThumb()) return mSlider->StartDrag(aEvent);
+
+  return NS_OK;
+}
+
+static bool ScrollFrameWillBuildScrollInfoLayer(nsIFrame* aScrollFrame) {
+  /*
+   * Note: if changing the conditions in this function, make a corresponding
+   * change to nsDisplayListBuilder::ShouldBuildScrollInfoItemsForHoisting()
+   * in nsDisplayList.cpp.
+   */
+  nsIFrame* current = aScrollFrame;
+  while (current) {
+    if (SVGIntegrationUtils::UsesSVGEffectsNotSupportedInCompositor(current)) {
+      return true;
+    }
+    current = nsLayoutUtils::GetParentOrPlaceholderForCrossDoc(current);
+  }
+  return false;
+}
+
+nsIScrollableFrame* nsSliderFrame::GetScrollFrame() {
+  return do_QueryFrame(Scrollbar()->GetParent());
+}
+
+void nsSliderFrame::StartAPZDrag(WidgetGUIEvent* aEvent) {
+  if (!aEvent->mFlags.mHandledByAPZ) {
+    return;
+  }
+
+  if (!gfxPlatform::GetPlatform()->SupportsApzDragInput()) {
+    return;
+  }
+
+  if (aEvent->AsMouseEvent() &&
+      aEvent->AsMouseEvent()->mButton != MouseButton::ePrimary) {
+    return;
+  }
+
+  nsIFrame* scrollbarBox = Scrollbar();
+  nsContainerFrame* scrollFrame = scrollbarBox->GetParent();
+  if (!scrollFrame) {
+    return;
+  }
+
+  nsIContent* scrollableContent = scrollFrame->GetContent();
+  if (!scrollableContent) {
+    return;
+  }
+
+  // APZ dragging requires the scrollbar to be layerized, which doesn't
+  // happen for scroll info layers.
+  if (ScrollFrameWillBuildScrollInfoLayer(scrollFrame)) {
+    return;
+  }
+
+  // Custom scrollbar mediators are not supported in the APZ codepath.
+  if (UsesCustomScrollbarMediator(scrollbarBox)) {
+    return;
+  }
+
+  bool isHorizontal = Scrollbar()->IsHorizontal();
+
+  layers::ScrollableLayerGuid::ViewID scrollTargetId;
+  bool hasID = nsLayoutUtils::FindIDFor(scrollableContent, &scrollTargetId);
+  bool hasAPZView =
+      hasID && scrollTargetId != layers::ScrollableLayerGuid::NULL_SCROLL_ID;
+
+  if (!hasAPZView) {
+    return;
+  }
+
+  if (!DisplayPortUtils::HasNonMinimalDisplayPort(scrollableContent)) {
+    return;
+  }
+
+  auto* presShell = PresShell();
+  uint64_t inputblockId = InputAPZContext::GetInputBlockId();
+  uint32_t presShellId = presShell->GetPresShellId();
+  AsyncDragMetrics dragMetrics(
+      scrollTargetId, presShellId, inputblockId,
+      OuterCSSPixel::FromAppUnits(mDragStart),
+      isHorizontal ? ScrollDirection::eHorizontal : ScrollDirection::eVertical);
+
+  // It's important to set this before calling
+  // nsIWidget::StartAsyncScrollbarDrag(), because in some configurations, that
+  // can call AsyncScrollbarDragRejected() synchronously, which clears the flag
+  // (and we want it to stay cleared in that case).
+  mScrollingWithAPZ = true;
+
+  // When we start an APZ drag, we wont get mouse events for the drag.
+  // APZ will consume them all and only notify us of the new scroll position.
+  bool waitForRefresh = InputAPZContext::HavePendingLayerization();
+  nsIWidget* widget = this->GetNearestWidget();
+  if (waitForRefresh) {
+    waitForRefresh = false;
+    if (nsPresContext* presContext = presShell->GetPresContext()) {
+      presContext->RegisterManagedPostRefreshObserver(
+          new ManagedPostRefreshObserver(
+              presContext, [widget = RefPtr<nsIWidget>(widget),
+                            dragMetrics](bool aWasCanceled) {
+                if (!aWasCanceled) {
+                  widget->StartAsyncScrollbarDrag(dragMetrics);
+                }
+                return ManagedPostRefreshObserver::Unregister::Yes;
+              }));
+      waitForRefresh = true;
+    }
+  }
+  if (!waitForRefresh) {
+    widget->StartAsyncScrollbarDrag(dragMetrics);
+  }
+}
+
+nsresult nsSliderFrame::StartDrag(Event* aEvent) {
+#ifdef DEBUG_SLIDER
+  printf("Begin dragging\n");
+#endif
+  if (mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
+                                         nsGkAtoms::_true, eCaseMatters))
+    return NS_OK;
+
+  WidgetGUIEvent* event = aEvent->WidgetEventPtr()->AsGUIEvent();
+
+  if (!ShouldScrollForEvent(event)) {
+    return NS_OK;
+  }
+
+  nsPoint pt;
+  if (!GetEventPoint(event, pt)) {
+    return NS_OK;
+  }
+  bool isHorizontal = Scrollbar()->IsHorizontal();
+  nscoord pos = isHorizontal ? pt.x : pt.y;
+
+  // If we should scroll-to-click, first place the middle of the slider thumb
+  // under the mouse.
+  nsCOMPtr<nsIContent> scrollbar;
+  nscoord newpos = pos;
+  bool scrollToClick = ShouldScrollToClickForEvent(event);
+  if (scrollToClick) {
+    // adjust so that the middle of the thumb is placed under the click
+    nsIFrame* thumbFrame = mFrames.FirstChild();
+    if (!thumbFrame) {
+      return NS_OK;
+    }
+    nsSize thumbSize = thumbFrame->GetSize();
+    nscoord thumbLength = isHorizontal ? thumbSize.width : thumbSize.height;
+
+    newpos -= (thumbLength / 2);
+
+    scrollbar = Scrollbar()->GetContent();
+  }
+
+  DragThumb(true);
+
+  if (scrollToClick) {
+    // should aMaySnap be true here?
+    SetCurrentThumbPosition(scrollbar, newpos, false, false);
+  }
+
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame) {
+    return NS_OK;
+  }
+
+  SetupDrag(event, thumbFrame, pos, isHorizontal);
+
+  return NS_OK;
+}
+
+nsresult nsSliderFrame::StopDrag() {
+  AddListener();
+  DragThumb(false);
+
+  mScrollingWithAPZ = false;
+
+  UnsuppressDisplayport();
+
+  if (mRepeatDirection) {
+    StopRepeat();
+    mRepeatDirection = 0;
+  }
+  return NS_OK;
+}
+
+void nsSliderFrame::DragThumb(bool aGrabMouseEvents) {
+  mDragFinished = !aGrabMouseEvents;
+
+  if (aGrabMouseEvents) {
+    PresShell::SetCapturingContent(
+        GetContent(),
+        CaptureFlags::IgnoreAllowedState | CaptureFlags::PreventDragStart);
+  } else {
+    PresShell::ReleaseCapturingContent();
+  }
+}
+
+bool nsSliderFrame::isDraggingThumb() const {
+  return PresShell::GetCapturingContent() == GetContent();
+}
+
+void nsSliderFrame::AddListener() {
+  if (!mMediator) {
+    mMediator = new nsSliderMediator(this);
+  }
+
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame) {
+    return;
+  }
+  thumbFrame->GetContent()->AddSystemEventListener(u"mousedown"_ns, mMediator,
+                                                   false, false);
+  thumbFrame->GetContent()->AddSystemEventListener(u"touchstart"_ns, mMediator,
+                                                   false, false);
+}
+
+void nsSliderFrame::RemoveListener() {
+  NS_ASSERTION(mMediator, "No listener was ever added!!");
+
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame) return;
+
+  thumbFrame->GetContent()->RemoveSystemEventListener(u"mousedown"_ns,
+                                                      mMediator, false);
+  thumbFrame->GetContent()->RemoveSystemEventListener(u"touchstart"_ns,
+                                                      mMediator, false);
+}
+
+bool nsSliderFrame::ShouldScrollForEvent(WidgetGUIEvent* aEvent) {
+  switch (aEvent->mMessage) {
+    case eTouchStart:
+    case eTouchEnd:
+      return true;
+    case eMouseDown:
+    case eMouseUp: {
+      uint16_t button = aEvent->AsMouseEvent()->mButton;
+#ifdef MOZ_WIDGET_GTK
+      return (button == MouseButton::ePrimary) ||
+             (button == MouseButton::eSecondary && GetScrollToClick()) ||
+             (button == MouseButton::eMiddle && gMiddlePref &&
+              !GetScrollToClick());
+#else
+      return (button == MouseButton::ePrimary) ||
+             (button == MouseButton::eMiddle && gMiddlePref);
+#endif
+    }
+    default:
+      return false;
+  }
+}
+
+bool nsSliderFrame::ShouldScrollToClickForEvent(WidgetGUIEvent* aEvent) {
+  if (!ShouldScrollForEvent(aEvent)) {
+    return false;
+  }
+
+  if (aEvent->mMessage != eMouseDown && aEvent->mMessage != eTouchStart) {
+    return false;
+  }
+
+#if defined(XP_MACOSX) || defined(MOZ_WIDGET_GTK)
+  // On Mac and Linux, clicking the scrollbar thumb should never scroll to
+  // click.
+  if (IsEventOverThumb(aEvent)) {
+    return false;
+  }
+#endif
+
+  if (aEvent->mMessage == eTouchStart) {
+    return GetScrollToClick();
+  }
+
+  WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
+  if (mouseEvent->mButton == MouseButton::ePrimary) {
+#ifdef XP_MACOSX
+    bool invertPref = mouseEvent->IsAlt();
+#else
+    bool invertPref = mouseEvent->IsShift();
+#endif
+    return GetScrollToClick() != invertPref;
+  }
+
+#ifdef MOZ_WIDGET_GTK
+  if (mouseEvent->mButton == MouseButton::eSecondary) {
+    return !GetScrollToClick();
+  }
+#endif
+
+  return true;
+}
+
+bool nsSliderFrame::IsEventOverThumb(WidgetGUIEvent* aEvent) {
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame) {
+    return false;
+  }
+
+  nsPoint eventPoint;
+  if (!GetEventPoint(aEvent, eventPoint)) {
+    return false;
+  }
+
+  const nsRect thumbRect = thumbFrame->GetRect();
+  const bool isHorizontal = Scrollbar()->IsHorizontal();
+  nscoord eventPos = isHorizontal ? eventPoint.x : eventPoint.y;
+  nscoord thumbStart = isHorizontal ? thumbRect.x : thumbRect.y;
+  nscoord thumbEnd = isHorizontal ? thumbRect.XMost() : thumbRect.YMost();
+  return eventPos >= thumbStart && eventPos < thumbEnd;
+}
+
+NS_IMETHODIMP
+nsSliderFrame::HandlePress(nsPresContext* aPresContext, WidgetGUIEvent* aEvent,
+                           nsEventStatus* aEventStatus) {
+  if (!ShouldScrollForEvent(aEvent) || ShouldScrollToClickForEvent(aEvent)) {
+    return NS_OK;
+  }
+
+  if (IsEventOverThumb(aEvent)) {
+    return NS_OK;
+  }
+
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame)  // display:none?
+    return NS_OK;
+
+  if (mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
+                                         nsGkAtoms::_true, eCaseMatters))
+    return NS_OK;
+
+  nsRect thumbRect = thumbFrame->GetRect();
+
+  nscoord change = 1;
+  nsPoint eventPoint;
+  if (!GetEventPoint(aEvent, eventPoint)) {
+    return NS_OK;
+  }
+
+  if (Scrollbar()->IsHorizontal() ? eventPoint.x < thumbRect.x
+                                  : eventPoint.y < thumbRect.y) {
+    change = -1;
+  }
+
+  mRepeatDirection = change;
+  DragThumb(true);
+  if (StaticPrefs::layout_scrollbars_click_and_hold_track_continue_to_end()) {
+    // Set the destination point to the very end of the scrollbar so that
+    // scrolling doesn't stop halfway through.
+    if (change > 0) {
+      mDestinationPoint = nsPoint(GetRect().width, GetRect().height);
+    } else {
+      mDestinationPoint = nsPoint(0, 0);
+    }
+  } else {
+    mDestinationPoint = eventPoint;
+  }
+  StartRepeat();
+  PageScroll(false);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSliderFrame::HandleRelease(nsPresContext* aPresContext,
+                             WidgetGUIEvent* aEvent,
+                             nsEventStatus* aEventStatus) {
+  StopRepeat();
+
+  nsScrollbarFrame* sb = Scrollbar();
+  if (nsIScrollbarMediator* m = sb->GetScrollbarMediator()) {
+    m->ScrollbarReleased(sb);
+  }
+  return NS_OK;
+}
+
+void nsSliderFrame::Destroy(DestroyContext& aContext) {
+  // tell our mediator if we have one we are gone.
+  if (mMediator) {
+    mMediator->SetSlider(nullptr);
+    mMediator = nullptr;
+  }
+  StopRepeat();
+
+  // call base class Destroy()
+  nsContainerFrame::Destroy(aContext);
+}
+
+void nsSliderFrame::Notify() {
+  bool stop = false;
+
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame) {
+    StopRepeat();
+    return;
+  }
+  nsRect thumbRect = thumbFrame->GetRect();
+
+  const bool isHorizontal = Scrollbar()->IsHorizontal();
+
+  // See if the thumb has moved past our destination point.
+  // if it has we want to stop.
+  if (isHorizontal) {
+    if (mRepeatDirection < 0) {
+      if (thumbRect.x < mDestinationPoint.x) stop = true;
+    } else {
+      if (thumbRect.x + thumbRect.width > mDestinationPoint.x) stop = true;
+    }
+  } else {
+    if (mRepeatDirection < 0) {
+      if (thumbRect.y < mDestinationPoint.y) stop = true;
+    } else {
+      if (thumbRect.y + thumbRect.height > mDestinationPoint.y) stop = true;
+    }
+  }
+
+  if (stop) {
+    StopRepeat();
+  } else {
+    PageScroll(true);
+  }
+}
+
+void nsSliderFrame::PageScroll(bool aClickAndHold) {
+  int32_t changeDirection = mRepeatDirection;
+  if (mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::dir,
+                                         nsGkAtoms::reverse, eCaseMatters)) {
+    changeDirection = -changeDirection;
+  }
+  nsScrollbarFrame* sb = Scrollbar();
+
+  nsIScrollableFrame* sf = GetScrollFrame();
+  const ScrollSnapFlags scrollSnapFlags =
+      ScrollSnapFlags::IntendedDirection | ScrollSnapFlags::IntendedEndPosition;
+
+  // If our nsIScrollbarMediator implementation is an nsIScrollableFrame,
+  // use ScrollTo() to ensure we do not scroll past the intended
+  // destination. Otherwise, the combination of smooth scrolling and
+  // ScrollBy() semantics (which adds the delta to the current destination
+  // if there is a smooth scroll in progress) can lead to scrolling too far
+  // (bug 1331390).
+  // Only do this when the page scroll is triggered by the repeat timer
+  // when the mouse is being held down. For multiple clicks in
+  // succession, we want to make sure we scroll by a full page for
+  // each click, so we use ScrollByPage().
+  if (aClickAndHold && sf) {
+    const bool isHorizontal = sb->IsHorizontal();
+
+    nsIFrame* thumbFrame = mFrames.FirstChild();
+    if (!thumbFrame) {
+      return;
+    }
+
+    nsRect thumbRect = thumbFrame->GetRect();
+
+    nscoord maxDistanceAlongTrack;
+    if (isHorizontal) {
+      maxDistanceAlongTrack =
+          mDestinationPoint.x - thumbRect.x - thumbRect.width / 2;
+    } else {
+      maxDistanceAlongTrack =
+          mDestinationPoint.y - thumbRect.y - thumbRect.height / 2;
+    }
+
+    // Convert distance along scrollbar track to amount of scrolled content.
+    nscoord maxDistanceToScroll = maxDistanceAlongTrack / GetThumbRatio();
+
+    nsIContent* content = sb->GetContent();
+    const CSSIntCoord pageLength = GetPageIncrement(content);
+
+    nsPoint pos = sf->GetScrollPosition();
+
+    if (mCurrentClickHoldDestination) {
+      // We may not have arrived at the destination of the scroll from the
+      // previous repeat timer tick, some of that scroll may still be pending.
+      nsPoint pendingScroll =
+          *mCurrentClickHoldDestination - sf->GetScrollPosition();
+
+      // Scroll by one page relative to the previous destination, so that we
+      // scroll at a rate of a full page per repeat timer tick.
+      pos += pendingScroll;
+
+      // Make a corresponding adjustment to the maxium distance we can scroll,
+      // so we successfully avoid overshoot.
+      maxDistanceToScroll -= (isHorizontal ? pendingScroll.x : pendingScroll.y);
+    }
+
+    nscoord distanceToScroll =
+        std::min(abs(maxDistanceToScroll),
+                 CSSPixel::ToAppUnits(CSSCoord(pageLength))) *
+        changeDirection;
+
+    if (isHorizontal) {
+      pos.x += distanceToScroll;
+    } else {
+      pos.y += distanceToScroll;
+    }
+
+    mCurrentClickHoldDestination = Some(pos);
+    sf->ScrollTo(pos,
+                 StaticPrefs::general_smoothScroll() &&
+                         StaticPrefs::general_smoothScroll_pages()
+                     ? ScrollMode::Smooth
+                     : ScrollMode::Instant,
+                 nullptr, scrollSnapFlags);
+
+    return;
+  }
+
+  sb->SetIncrementToPage(changeDirection);
+  if (nsIScrollbarMediator* m = sb->GetScrollbarMediator()) {
+    m->ScrollByPage(sb, changeDirection, scrollSnapFlags);
+    return;
+  }
+  PageUpDown(changeDirection);
+}
+
+void nsSliderFrame::SetupDrag(WidgetGUIEvent* aEvent, nsIFrame* aThumbFrame,
+                              nscoord aPos, bool aIsHorizontal) {
+  if (aIsHorizontal) {
+    mThumbStart = aThumbFrame->GetPosition().x;
+  } else {
+    mThumbStart = aThumbFrame->GetPosition().y;
+  }
+
+  mDragStart = aPos - mThumbStart;
+
+  mScrollingWithAPZ = false;
+  StartAPZDrag(aEvent);  // sets mScrollingWithAPZ=true if appropriate
+
+#ifdef DEBUG_SLIDER
+  printf("Pressed mDragStart=%d\n", mDragStart);
+#endif
+
+  if (!mScrollingWithAPZ) {
+    SuppressDisplayport();
+  }
+}
+
+float nsSliderFrame::GetThumbRatio() const {
+  // mRatio is in thumb app units per scrolled css pixels. Convert it to a
+  // ratio of the thumb's CSS pixels per scrolled CSS pixels. (Note the thumb
+  // is in the scrollframe's parent's space whereas the scrolled CSS pixels
+  // are in the scrollframe's space).
+  return mRatio / AppUnitsPerCSSPixel();
+}
+
+void nsSliderFrame::AsyncScrollbarDragInitiated(uint64_t aDragBlockId) {
+  mAPZDragInitiated = Some(aDragBlockId);
+}
+
+void nsSliderFrame::AsyncScrollbarDragRejected() {
+  mScrollingWithAPZ = false;
+  // Only suppress the displayport if we're still dragging the thumb.
+  // Otherwise, no one will unsuppress it.
+  if (isDraggingThumb()) {
+    SuppressDisplayport();
+  }
+}
+
+void nsSliderFrame::SuppressDisplayport() {
+  if (!mSuppressionActive) {
+    PresShell()->SuppressDisplayport(true);
+    mSuppressionActive = true;
+  }
+}
+
+void nsSliderFrame::UnsuppressDisplayport() {
+  if (mSuppressionActive) {
+    PresShell()->SuppressDisplayport(false);
+    mSuppressionActive = false;
+  }
+}
+
+bool nsSliderFrame::OnlySystemGroupDispatch(EventMessage aMessage) const {
+  // If we are in a native anonymous subtree, do not dispatch mouse-move or
+  // pointer-move events targeted at this slider frame to web content. This
+  // matches the behaviour of other browsers.
+  return (aMessage == eMouseMove || aMessage == ePointerMove) &&
+         isDraggingThumb() && GetContent()->IsInNativeAnonymousSubtree();
+}
+
+bool nsSliderFrame::GetEventPoint(WidgetGUIEvent* aEvent, nsPoint& aPoint) {
+  LayoutDeviceIntPoint refPoint;
+  if (!GetEventPoint(aEvent, refPoint)) {
+    return false;
+  }
+  aPoint = nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, refPoint,
+                                                        RelativeTo{this});
+  return true;
+}
+
+bool nsSliderFrame::GetEventPoint(WidgetGUIEvent* aEvent,
+                                  LayoutDeviceIntPoint& aPoint) {
+  NS_ENSURE_TRUE(aEvent, false);
+  WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent();
+  if (touchEvent) {
+    // return false if there is more than one touch on the page, or if
+    // we can't find a touch point
+    if (touchEvent->mTouches.Length() != 1) {
+      return false;
+    }
+
+    dom::Touch* touch = touchEvent->mTouches.SafeElementAt(0);
+    if (!touch) {
+      return false;
+    }
+    aPoint = touch->mRefPoint;
+  } else {
+    aPoint = aEvent->mRefPoint;
+  }
+  return true;
+}
+
+NS_IMPL_ISUPPORTS(nsSliderMediator, nsIDOMEventListener)