Adding upstream version 110.0.1.upstream/110.0.1upstream

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

1 files changed, 1689 insertions, 0 deletions

diff --git a/widget/Theme.cpp b/widget/Theme.cpp
new file mode 100644
index 0000000000..26f912417e
--- /dev/null
+++ b/widget/Theme.cpp
@@ -0,0 +1,1689 @@
+/* -*- Mode: C++; tab-width: 40; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "Theme.h"
+#include <utility>
+#include "ThemeCocoa.h"
+
+#include "ThemeDrawing.h"
+#include "Units.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/HTMLMeterElement.h"
+#include "mozilla/dom/HTMLProgressElement.h"
+#include "mozilla/gfx/Rect.h"
+#include "mozilla/gfx/Types.h"
+#include "mozilla/gfx/Filters.h"
+#include "mozilla/RelativeLuminanceUtils.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "nsCSSColorUtils.h"
+#include "nsCSSRendering.h"
+#include "nsScrollbarFrame.h"
+#include "nsIScrollbarMediator.h"
+#include "nsDeviceContext.h"
+#include "nsLayoutUtils.h"
+#include "nsRangeFrame.h"
+#include "PathHelpers.h"
+#include "ScrollbarDrawingAndroid.h"
+#include "ScrollbarDrawingCocoa.h"
+#include "ScrollbarDrawingGTK.h"
+#include "ScrollbarDrawingWin.h"
+#include "ScrollbarDrawingWin11.h"
+
+#ifdef XP_WIN
+#  include "mozilla/WindowsVersion.h"
+#endif
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+using namespace mozilla::widget;
+
+namespace {
+
+static constexpr gfx::sRGBColor sColorGrey10(
+    gfx::sRGBColor::UnusualFromARGB(0xffe9e9ed));
+static constexpr gfx::sRGBColor sColorGrey10Alpha50(
+    gfx::sRGBColor::UnusualFromARGB(0x7fe9e9ed));
+static constexpr gfx::sRGBColor sColorGrey20(
+    gfx::sRGBColor::UnusualFromARGB(0xffd0d0d7));
+static constexpr gfx::sRGBColor sColorGrey30(
+    gfx::sRGBColor::UnusualFromARGB(0xffb1b1b9));
+static constexpr gfx::sRGBColor sColorGrey40(
+    gfx::sRGBColor::UnusualFromARGB(0xff8f8f9d));
+static constexpr gfx::sRGBColor sColorGrey40Alpha50(
+    gfx::sRGBColor::UnusualFromARGB(0x7f8f8f9d));
+static constexpr gfx::sRGBColor sColorGrey50(
+    gfx::sRGBColor::UnusualFromARGB(0xff676774));
+static constexpr gfx::sRGBColor sColorGrey60(
+    gfx::sRGBColor::UnusualFromARGB(0xff484851));
+
+static constexpr gfx::sRGBColor sColorMeterGreen10(
+    gfx::sRGBColor::UnusualFromARGB(0xff00ab60));
+static constexpr gfx::sRGBColor sColorMeterGreen20(
+    gfx::sRGBColor::UnusualFromARGB(0xff056139));
+static constexpr gfx::sRGBColor sColorMeterYellow10(
+    gfx::sRGBColor::UnusualFromARGB(0xffffbd4f));
+static constexpr gfx::sRGBColor sColorMeterYellow20(
+    gfx::sRGBColor::UnusualFromARGB(0xffd2811e));
+static constexpr gfx::sRGBColor sColorMeterRed10(
+    gfx::sRGBColor::UnusualFromARGB(0xffe22850));
+static constexpr gfx::sRGBColor sColorMeterRed20(
+    gfx::sRGBColor::UnusualFromARGB(0xff810220));
+
+static const CSSCoord kMinimumRangeThumbSize = 20.0f;
+static const CSSCoord kMinimumDropdownArrowButtonWidth = 18.0f;
+static const CSSCoord kMinimumSpinnerButtonWidth = 18.0f;
+static const CSSCoord kMinimumSpinnerButtonHeight = 9.0f;
+static const CSSCoord kButtonBorderWidth = 1.0f;
+static const CSSCoord kMenulistBorderWidth = 1.0f;
+static const CSSCoord kTextFieldBorderWidth = 1.0f;
+static const CSSCoord kRangeHeight = 6.0f;
+static const CSSCoord kProgressbarHeight = 6.0f;
+static const CSSCoord kMeterHeight = 12.0f;
+
+// nsCheckboxRadioFrame takes the bottom of the content box as the baseline.
+// This border-width makes its baseline 2px under the bottom, which is nice.
+static constexpr CSSCoord kCheckboxRadioBorderWidth = 2.0f;
+
+static constexpr sRGBColor sTransparent = sRGBColor::White(0.0);
+
+// This pushes and pops a clip rect to the draw target.
+//
+// This is done to reduce fuzz in places where we may have antialiasing,
+// because skia is not clip-invariant: given different clips, it does not
+// guarantee the same result, even if the painted content doesn't intersect
+// the clips.
+//
+// This is a bit sad, overall, but...
+struct MOZ_RAII AutoClipRect {
+  AutoClipRect(DrawTarget& aDt, const LayoutDeviceRect& aRect) : mDt(aDt) {
+    mDt.PushClipRect(aRect.ToUnknownRect());
+  }
+
+  ~AutoClipRect() { mDt.PopClip(); }
+
+ private:
+  DrawTarget& mDt;
+};
+
+static StaticRefPtr<Theme> gNativeInstance;
+static StaticRefPtr<Theme> gNonNativeInstance;
+static StaticRefPtr<Theme> gRDMInstance;
+
+}  // namespace
+
+#ifdef ANDROID
+already_AddRefed<Theme> do_CreateNativeThemeDoNotUseDirectly() {
+  // Android doesn't have a native theme.
+  return do_AddRef(new Theme(Theme::ScrollbarStyle()));
+}
+#endif
+
+already_AddRefed<nsITheme> do_GetBasicNativeThemeDoNotUseDirectly() {
+  if (MOZ_UNLIKELY(!gNonNativeInstance)) {
+    UniquePtr<ScrollbarDrawing> scrollbarDrawing = Theme::ScrollbarStyle();
+#ifdef MOZ_WIDGET_COCOA
+    gNonNativeInstance = new ThemeCocoa(std::move(scrollbarDrawing));
+#else
+    gNonNativeInstance = new Theme(std::move(scrollbarDrawing));
+#endif
+    ClearOnShutdown(&gNonNativeInstance);
+  }
+  return do_AddRef(gNonNativeInstance);
+}
+
+already_AddRefed<nsITheme> do_GetNativeThemeDoNotUseDirectly() {
+  if (MOZ_UNLIKELY(!gNativeInstance)) {
+    gNativeInstance = do_CreateNativeThemeDoNotUseDirectly();
+    ClearOnShutdown(&gNativeInstance);
+  }
+  return do_AddRef(gNativeInstance);
+}
+
+already_AddRefed<nsITheme> do_GetRDMThemeDoNotUseDirectly() {
+  if (MOZ_UNLIKELY(!gRDMInstance)) {
+    gRDMInstance = new Theme(MakeUnique<ScrollbarDrawingAndroid>());
+    ClearOnShutdown(&gRDMInstance);
+  }
+  return do_AddRef(gRDMInstance);
+}
+
+namespace mozilla::widget {
+
+NS_IMPL_ISUPPORTS_INHERITED(Theme, nsNativeTheme, nsITheme)
+
+static constexpr nsLiteralCString kPrefs[] = {
+    "widget.non-native-theme.use-theme-accent"_ns,
+    "widget.non-native-theme.win.scrollbar.use-system-size"_ns,
+    "widget.non-native-theme.scrollbar.size.override"_ns,
+    "widget.non-native-theme.scrollbar.style"_ns,
+};
+
+void Theme::Init() {
+  for (const auto& pref : kPrefs) {
+    Preferences::RegisterCallback(PrefChangedCallback, pref);
+  }
+  LookAndFeelChanged();
+}
+
+void Theme::Shutdown() {
+  for (const auto& pref : kPrefs) {
+    Preferences::UnregisterCallback(PrefChangedCallback, pref);
+  }
+}
+
+/* static */
+void Theme::LookAndFeelChanged() {
+  ThemeColors::RecomputeAccentColors();
+  if (gNonNativeInstance) {
+    gNonNativeInstance->SetScrollbarDrawing(ScrollbarStyle());
+  }
+  if (gNativeInstance) {
+    gNativeInstance->SetScrollbarDrawing(ScrollbarStyle());
+  }
+}
+
+/* static */
+auto Theme::GetDPIRatio(nsPresContext* aPc, StyleAppearance aAppearance)
+    -> DPIRatio {
+  // Widgets react to zoom, except scrollbars.
+  if (IsWidgetScrollbarPart(aAppearance)) {
+    return ScrollbarDrawing::GetDPIRatioForScrollbarPart(aPc);
+  }
+  return DPIRatio(float(AppUnitsPerCSSPixel()) / aPc->AppUnitsPerDevPixel());
+}
+
+/* static */
+auto Theme::GetDPIRatio(nsIFrame* aFrame, StyleAppearance aAppearance)
+    -> DPIRatio {
+  return GetDPIRatio(aFrame->PresContext(), aAppearance);
+}
+
+// Checkbox and radio need to preserve aspect-ratio for compat. We also snap the
+// size to exact device pixels to avoid snapping disorting the circles.
+static LayoutDeviceRect CheckBoxRadioRect(const LayoutDeviceRect& aRect) {
+  // Place a square rect in the center of aRect.
+  auto size = std::trunc(std::min(aRect.width, aRect.height));
+  auto position = aRect.Center() - LayoutDevicePoint(size * 0.5, size * 0.5);
+  return LayoutDeviceRect(position, LayoutDeviceSize(size, size));
+}
+
+std::tuple<sRGBColor, sRGBColor, sRGBColor> Theme::ComputeCheckboxColors(
+    const ElementState& aState, StyleAppearance aAppearance,
+    const Colors& aColors) {
+  MOZ_ASSERT(aAppearance == StyleAppearance::Checkbox ||
+             aAppearance == StyleAppearance::Radio);
+
+  bool isDisabled = aState.HasState(ElementState::DISABLED);
+  bool isChecked = aState.HasState(ElementState::CHECKED);
+  bool isIndeterminate = aAppearance == StyleAppearance::Checkbox &&
+                         aState.HasState(ElementState::INDETERMINATE);
+
+  if (isChecked || isIndeterminate) {
+    if (isDisabled) {
+      auto bg = ComputeBorderColor(aState, aColors, OutlineCoversBorder::No);
+      auto fg = aColors.HighContrast()
+                    ? aColors.System(StyleSystemColor::Graytext)
+                    : sRGBColor::White(.8f);
+      return std::make_tuple(bg, bg, fg);
+    }
+
+    if (aColors.HighContrast()) {
+      auto bg = aColors.System(StyleSystemColor::Selecteditem);
+      auto fg = aColors.System(StyleSystemColor::Selecteditemtext);
+      return std::make_tuple(bg, bg, fg);
+    }
+
+    bool isActive =
+        aState.HasAllStates(ElementState::HOVER | ElementState::ACTIVE);
+    bool isHovered = aState.HasState(ElementState::HOVER);
+    const auto& bg = isActive    ? aColors.Accent().GetDarker()
+                     : isHovered ? aColors.Accent().GetDark()
+                                 : aColors.Accent().Get();
+    const auto& fg = aColors.Accent().GetForeground();
+    return std::make_tuple(bg, bg, fg);
+  }
+
+  auto [bg, border] =
+      ComputeTextfieldColors(aState, aColors, OutlineCoversBorder::No);
+  // We don't paint a checkmark in this case so any color would do.
+  return std::make_tuple(bg, border, sTransparent);
+}
+
+sRGBColor Theme::ComputeBorderColor(const ElementState& aState,
+                                    const Colors& aColors,
+                                    OutlineCoversBorder aOutlineCoversBorder) {
+  bool isDisabled = aState.HasState(ElementState::DISABLED);
+  if (aColors.HighContrast()) {
+    return aColors.System(isDisabled ? StyleSystemColor::Graytext
+                                     : StyleSystemColor::Buttontext);
+  }
+  bool isActive =
+      aState.HasAllStates(ElementState::HOVER | ElementState::ACTIVE);
+  bool isHovered = aState.HasState(ElementState::HOVER);
+  bool isFocused = aState.HasState(ElementState::FOCUSRING);
+  if (isDisabled) {
+    return sColorGrey40Alpha50;
+  }
+  if (isFocused && aOutlineCoversBorder == OutlineCoversBorder::Yes) {
+    // If we draw the outline over the border, prevent issues where the border
+    // shows underneath if it snaps in the wrong direction by using a
+    // transparent border. An alternative to this is ensuring that we snap the
+    // offset in PaintRoundedFocusRect the same was a we snap border widths, so
+    // that negative offsets are guaranteed to cover the border.
+    // But this looks harder to mess up.
+    return sTransparent;
+  }
+  bool dark = aColors.IsDark();
+  if (isActive) {
+    return dark ? sColorGrey20 : sColorGrey60;
+  }
+  if (isHovered) {
+    return dark ? sColorGrey30 : sColorGrey50;
+  }
+  return sColorGrey40;
+}
+
+std::pair<sRGBColor, sRGBColor> Theme::ComputeButtonColors(
+    const ElementState& aState, const Colors& aColors, nsIFrame* aFrame) {
+  bool isActive =
+      aState.HasAllStates(ElementState::HOVER | ElementState::ACTIVE);
+  bool isDisabled = aState.HasState(ElementState::DISABLED);
+  bool isHovered = aState.HasState(ElementState::HOVER);
+
+  nscolor backgroundColor = [&] {
+    if (isDisabled) {
+      return aColors.SystemNs(StyleSystemColor::MozButtondisabledface);
+    }
+    if (isActive) {
+      return aColors.SystemNs(StyleSystemColor::MozButtonactiveface);
+    }
+    if (isHovered) {
+      return aColors.SystemNs(StyleSystemColor::MozButtonhoverface);
+    }
+    return aColors.SystemNs(StyleSystemColor::Buttonface);
+  }();
+
+  if (aState.HasState(ElementState::AUTOFILL)) {
+    backgroundColor = NS_ComposeColors(
+        backgroundColor,
+        aColors.SystemNs(StyleSystemColor::MozAutofillBackground));
+  }
+
+  const sRGBColor borderColor =
+      ComputeBorderColor(aState, aColors, OutlineCoversBorder::Yes);
+  return std::make_pair(sRGBColor::FromABGR(backgroundColor), borderColor);
+}
+
+std::pair<sRGBColor, sRGBColor> Theme::ComputeTextfieldColors(
+    const ElementState& aState, const Colors& aColors,
+    OutlineCoversBorder aOutlineCoversBorder) {
+  nscolor backgroundColor = [&] {
+    if (aState.HasState(ElementState::DISABLED)) {
+      return aColors.SystemNs(StyleSystemColor::MozDisabledfield);
+    }
+    return aColors.SystemNs(StyleSystemColor::Field);
+  }();
+
+  if (aState.HasState(ElementState::AUTOFILL)) {
+    backgroundColor = NS_ComposeColors(
+        backgroundColor,
+        aColors.SystemNs(StyleSystemColor::MozAutofillBackground));
+  }
+
+  const sRGBColor borderColor =
+      ComputeBorderColor(aState, aColors, aOutlineCoversBorder);
+  return std::make_pair(sRGBColor::FromABGR(backgroundColor), borderColor);
+}
+
+std::pair<sRGBColor, sRGBColor> Theme::ComputeRangeProgressColors(
+    const ElementState& aState, const Colors& aColors) {
+  if (aColors.HighContrast()) {
+    return aColors.SystemPair(StyleSystemColor::Selecteditem,
+                              StyleSystemColor::Buttontext);
+  }
+
+  bool isActive =
+      aState.HasAllStates(ElementState::HOVER | ElementState::ACTIVE);
+  bool isDisabled = aState.HasState(ElementState::DISABLED);
+  bool isHovered = aState.HasState(ElementState::HOVER);
+
+  if (isDisabled) {
+    return std::make_pair(sColorGrey40Alpha50, sColorGrey40Alpha50);
+  }
+  if (isActive || isHovered) {
+    return std::make_pair(aColors.Accent().GetDark(),
+                          aColors.Accent().GetDarker());
+  }
+  return std::make_pair(aColors.Accent().Get(), aColors.Accent().GetDark());
+}
+
+std::pair<sRGBColor, sRGBColor> Theme::ComputeRangeTrackColors(
+    const ElementState& aState, const Colors& aColors) {
+  if (aColors.HighContrast()) {
+    return aColors.SystemPair(StyleSystemColor::Window,
+                              StyleSystemColor::Buttontext);
+  }
+  bool isActive =
+      aState.HasAllStates(ElementState::HOVER | ElementState::ACTIVE);
+  bool isDisabled = aState.HasState(ElementState::DISABLED);
+  bool isHovered = aState.HasState(ElementState::HOVER);
+
+  if (isDisabled) {
+    return std::make_pair(sColorGrey10Alpha50, sColorGrey40Alpha50);
+  }
+  if (isActive || isHovered) {
+    return std::make_pair(sColorGrey20, sColorGrey50);
+  }
+  return std::make_pair(sColorGrey10, sColorGrey40);
+}
+
+std::pair<sRGBColor, sRGBColor> Theme::ComputeRangeThumbColors(
+    const ElementState& aState, const Colors& aColors) {
+  if (aColors.HighContrast()) {
+    return aColors.SystemPair(StyleSystemColor::Selecteditemtext,
+                              StyleSystemColor::Selecteditem);
+  }
+
+  bool isActive =
+      aState.HasAllStates(ElementState::HOVER | ElementState::ACTIVE);
+  bool isDisabled = aState.HasState(ElementState::DISABLED);
+  bool isHovered = aState.HasState(ElementState::HOVER);
+
+  const sRGBColor& backgroundColor = [&] {
+    if (isDisabled) {
+      return sColorGrey40;
+    }
+    if (isActive) {
+      return aColors.Accent().Get();
+    }
+    if (isHovered) {
+      return sColorGrey60;
+    }
+    return sColorGrey50;
+  }();
+
+  const sRGBColor borderColor = sRGBColor::OpaqueWhite();
+  return std::make_pair(backgroundColor, borderColor);
+}
+
+std::pair<sRGBColor, sRGBColor> Theme::ComputeProgressColors(
+    const Colors& aColors) {
+  if (aColors.HighContrast()) {
+    return aColors.SystemPair(StyleSystemColor::Selecteditem,
+                              StyleSystemColor::Buttontext);
+  }
+  return std::make_pair(aColors.Accent().Get(), aColors.Accent().GetDark());
+}
+
+std::pair<sRGBColor, sRGBColor> Theme::ComputeProgressTrackColors(
+    const Colors& aColors) {
+  if (aColors.HighContrast()) {
+    return aColors.SystemPair(StyleSystemColor::Buttonface,
+                              StyleSystemColor::Buttontext);
+  }
+  return std::make_pair(sColorGrey10, sColorGrey40);
+}
+
+std::pair<sRGBColor, sRGBColor> Theme::ComputeMeterchunkColors(
+    const ElementState& aMeterState, const Colors& aColors) {
+  if (aColors.HighContrast()) {
+    return ComputeProgressColors(aColors);
+  }
+  sRGBColor borderColor = sColorMeterGreen20;
+  sRGBColor chunkColor = sColorMeterGreen10;
+
+  if (aMeterState.HasState(ElementState::SUB_OPTIMUM)) {
+    borderColor = sColorMeterYellow20;
+    chunkColor = sColorMeterYellow10;
+  } else if (aMeterState.HasState(ElementState::SUB_SUB_OPTIMUM)) {
+    borderColor = sColorMeterRed20;
+    chunkColor = sColorMeterRed10;
+  }
+
+  return std::make_pair(chunkColor, borderColor);
+}
+
+std::array<sRGBColor, 3> Theme::ComputeFocusRectColors(const Colors& aColors) {
+  if (aColors.HighContrast()) {
+    return {aColors.System(StyleSystemColor::Selecteditem),
+            aColors.System(StyleSystemColor::Buttontext),
+            aColors.System(StyleSystemColor::Window)};
+  }
+  const auto& accent = aColors.Accent();
+  const sRGBColor middle =
+      aColors.IsDark() ? sRGBColor::Black(.3f) : sRGBColor::White(.3f);
+  return {accent.Get(), middle, accent.GetLight()};
+}
+
+template <typename PaintBackendData>
+void Theme::PaintRoundedFocusRect(PaintBackendData& aBackendData,
+                                  const LayoutDeviceRect& aRect,
+                                  const Colors& aColors, DPIRatio aDpiRatio,
+                                  CSSCoord aRadius, CSSCoord aOffset) {
+  // NOTE(emilio): If the widths or offsets here change, make sure to tweak
+  // the GetWidgetOverflow path for FocusOutline.
+  auto [innerColor, middleColor, outerColor] = ComputeFocusRectColors(aColors);
+
+  LayoutDeviceRect focusRect(aRect);
+
+  // The focus rect is painted outside of the border area (aRect), see:
+  //
+  //   data:text/html,<div style="border: 1px solid; outline: 2px solid
+  //   red">Foobar</div>
+  //
+  // But some controls might provide a negative offset to cover the border, if
+  // necessary.
+  CSSCoord strokeWidth = 2.0f;
+  auto strokeWidthDevPx =
+      LayoutDeviceCoord(ThemeDrawing::SnapBorderWidth(strokeWidth, aDpiRatio));
+  CSSCoord strokeRadius = aRadius;
+  focusRect.Inflate(aOffset * aDpiRatio + strokeWidthDevPx);
+
+  ThemeDrawing::PaintRoundedRectWithRadius(
+      aBackendData, focusRect, sTransparent, innerColor, strokeWidth,
+      strokeRadius, aDpiRatio);
+
+  strokeWidth = CSSCoord(1.0f);
+  strokeWidthDevPx =
+      LayoutDeviceCoord(ThemeDrawing::SnapBorderWidth(strokeWidth, aDpiRatio));
+  strokeRadius += strokeWidth;
+  focusRect.Inflate(strokeWidthDevPx);
+
+  ThemeDrawing::PaintRoundedRectWithRadius(
+      aBackendData, focusRect, sTransparent, middleColor, strokeWidth,
+      strokeRadius, aDpiRatio);
+
+  strokeWidth = CSSCoord(2.0f);
+  strokeWidthDevPx =
+      LayoutDeviceCoord(ThemeDrawing::SnapBorderWidth(strokeWidth, aDpiRatio));
+  strokeRadius += strokeWidth;
+  focusRect.Inflate(strokeWidthDevPx);
+
+  ThemeDrawing::PaintRoundedRectWithRadius(
+      aBackendData, focusRect, sTransparent, outerColor, strokeWidth,
+      strokeRadius, aDpiRatio);
+}
+
+void Theme::PaintCheckboxControl(DrawTarget& aDrawTarget,
+                                 const LayoutDeviceRect& aRect,
+                                 const ElementState& aState,
+                                 const Colors& aColors, DPIRatio aDpiRatio) {
+  auto [backgroundColor, borderColor, checkColor] =
+      ComputeCheckboxColors(aState, StyleAppearance::Checkbox, aColors);
+  {
+    const CSSCoord radius = 2.0f;
+    CSSCoord borderWidth = kCheckboxRadioBorderWidth;
+    if (backgroundColor == borderColor) {
+      borderWidth = 0.0f;
+    }
+    ThemeDrawing::PaintRoundedRectWithRadius(aDrawTarget, aRect,
+                                             backgroundColor, borderColor,
+                                             borderWidth, radius, aDpiRatio);
+  }
+
+  if (aState.HasState(ElementState::INDETERMINATE)) {
+    PaintIndeterminateMark(aDrawTarget, aRect, checkColor);
+  } else if (aState.HasState(ElementState::CHECKED)) {
+    PaintCheckMark(aDrawTarget, aRect, checkColor);
+  }
+
+  if (aState.HasState(ElementState::FOCUSRING)) {
+    PaintRoundedFocusRect(aDrawTarget, aRect, aColors, aDpiRatio, 5.0f, 1.0f);
+  }
+}
+
+constexpr CSSCoord kCheckboxRadioContentBoxSize = 10.0f;
+constexpr CSSCoord kCheckboxRadioBorderBoxSize =
+    kCheckboxRadioContentBoxSize + kCheckboxRadioBorderWidth * 2.0f;
+
+void Theme::PaintCheckMark(DrawTarget& aDrawTarget,
+                           const LayoutDeviceRect& aRect,
+                           const sRGBColor& aColor) {
+  // Points come from the coordinates on a 14X14 (kCheckboxRadioBorderBoxSize)
+  // unit box centered at 0,0
+  const float checkPolygonX[] = {-4.5f, -1.5f, -0.5f, 5.0f, 4.75f,
+                                 3.5f,  -0.5f, -1.5f, -3.5f};
+  const float checkPolygonY[] = {0.5f,  4.0f, 4.0f,  -2.5f, -4.0f,
+                                 -4.0f, 1.0f, 1.25f, -1.0f};
+  const int32_t checkNumPoints = sizeof(checkPolygonX) / sizeof(float);
+  const float scale =
+      ThemeDrawing::ScaleToFillRect(aRect, kCheckboxRadioBorderBoxSize);
+  auto center = aRect.Center().ToUnknownPoint();
+
+  RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder();
+  Point p = center + Point(checkPolygonX[0] * scale, checkPolygonY[0] * scale);
+  builder->MoveTo(p);
+  for (int32_t i = 1; i < checkNumPoints; i++) {
+    p = center + Point(checkPolygonX[i] * scale, checkPolygonY[i] * scale);
+    builder->LineTo(p);
+  }
+  RefPtr<Path> path = builder->Finish();
+
+  aDrawTarget.Fill(path, ColorPattern(ToDeviceColor(aColor)));
+}
+
+void Theme::PaintIndeterminateMark(DrawTarget& aDrawTarget,
+                                   const LayoutDeviceRect& aRect,
+                                   const sRGBColor& aColor) {
+  const CSSCoord borderWidth = 2.0f;
+  const float scale =
+      ThemeDrawing::ScaleToFillRect(aRect, kCheckboxRadioBorderBoxSize);
+
+  Rect rect = aRect.ToUnknownRect();
+  rect.y += (rect.height / 2) - (borderWidth * scale / 2);
+  rect.height = borderWidth * scale;
+  rect.x += (borderWidth * scale) + (borderWidth * scale / 8);
+  rect.width -= ((borderWidth * scale) + (borderWidth * scale / 8)) * 2;
+
+  aDrawTarget.FillRect(rect, ColorPattern(ToDeviceColor(aColor)));
+}
+
+template <typename PaintBackendData>
+void Theme::PaintStrokedCircle(PaintBackendData& aPaintData,
+                               const LayoutDeviceRect& aRect,
+                               const sRGBColor& aBackgroundColor,
+                               const sRGBColor& aBorderColor,
+                               const CSSCoord aBorderWidth,
+                               DPIRatio aDpiRatio) {
+  auto radius = LayoutDeviceCoord(aRect.Size().width) / aDpiRatio;
+  ThemeDrawing::PaintRoundedRectWithRadius(aPaintData, aRect, aBackgroundColor,
+                                           aBorderColor, aBorderWidth, radius,
+                                           aDpiRatio);
+}
+
+void Theme::PaintCircleShadow(WebRenderBackendData& aWrData,
+                              const LayoutDeviceRect& aBoxRect,
+                              const LayoutDeviceRect& aClipRect,
+                              float aShadowAlpha, const CSSPoint& aShadowOffset,
+                              CSSCoord aShadowBlurStdDev, DPIRatio aDpiRatio) {
+  const bool kBackfaceIsVisible = true;
+  const LayoutDeviceCoord stdDev = aShadowBlurStdDev * aDpiRatio;
+  const LayoutDevicePoint shadowOffset = aShadowOffset * aDpiRatio;
+  const IntSize inflation =
+      gfxAlphaBoxBlur::CalculateBlurRadius(gfxPoint(stdDev, stdDev));
+  LayoutDeviceRect shadowRect = aBoxRect;
+  shadowRect.MoveBy(shadowOffset);
+  shadowRect.Inflate(inflation.width, inflation.height);
+  const auto boxRect = wr::ToLayoutRect(aBoxRect);
+  aWrData.mBuilder.PushBoxShadow(
+      wr::ToLayoutRect(shadowRect), wr::ToLayoutRect(aClipRect),
+      kBackfaceIsVisible, boxRect,
+      wr::ToLayoutVector2D(aShadowOffset * aDpiRatio),
+      wr::ToColorF(DeviceColor(0.0f, 0.0f, 0.0f, aShadowAlpha)), stdDev,
+      /* aSpread = */ 0.0f,
+      wr::ToBorderRadius(gfx::RectCornerRadii(aBoxRect.Size().width)),
+      wr::BoxShadowClipMode::Outset);
+}
+
+void Theme::PaintCircleShadow(DrawTarget& aDrawTarget,
+                              const LayoutDeviceRect& aBoxRect,
+                              const LayoutDeviceRect& aClipRect,
+                              float aShadowAlpha, const CSSPoint& aShadowOffset,
+                              CSSCoord aShadowBlurStdDev, DPIRatio aDpiRatio) {
+  Float stdDev = aShadowBlurStdDev * aDpiRatio;
+  Point offset = (aShadowOffset * aDpiRatio).ToUnknownPoint();
+
+  RefPtr<FilterNode> blurFilter =
+      aDrawTarget.CreateFilter(FilterType::GAUSSIAN_BLUR);
+  if (!blurFilter) {
+    return;
+  }
+
+  blurFilter->SetAttribute(ATT_GAUSSIAN_BLUR_STD_DEVIATION, stdDev);
+
+  IntSize inflation =
+      gfxAlphaBoxBlur::CalculateBlurRadius(gfxPoint(stdDev, stdDev));
+  Rect inflatedRect = aBoxRect.ToUnknownRect();
+  inflatedRect.Inflate(inflation.width, inflation.height);
+  Rect sourceRectInFilterSpace =
+      inflatedRect - aBoxRect.TopLeft().ToUnknownPoint();
+  Point destinationPointOfSourceRect = inflatedRect.TopLeft() + offset;
+
+  IntSize dtSize = RoundedToInt(aBoxRect.Size().ToUnknownSize());
+  RefPtr<DrawTarget> ellipseDT = aDrawTarget.CreateSimilarDrawTargetForFilter(
+      dtSize, SurfaceFormat::A8, blurFilter, blurFilter,
+      sourceRectInFilterSpace, destinationPointOfSourceRect);
+  if (!ellipseDT) {
+    return;
+  }
+
+  AutoClipRect clipRect(aDrawTarget, aClipRect);
+
+  RefPtr<Path> ellipse = MakePathForEllipse(
+      *ellipseDT, (aBoxRect - aBoxRect.TopLeft()).Center().ToUnknownPoint(),
+      aBoxRect.Size().ToUnknownSize());
+  ellipseDT->Fill(ellipse,
+                  ColorPattern(DeviceColor(0.0f, 0.0f, 0.0f, aShadowAlpha)));
+  RefPtr<SourceSurface> ellipseSurface = ellipseDT->Snapshot();
+
+  blurFilter->SetInput(IN_GAUSSIAN_BLUR_IN, ellipseSurface);
+  aDrawTarget.DrawFilter(blurFilter, sourceRectInFilterSpace,
+                         destinationPointOfSourceRect);
+}
+
+template <typename PaintBackendData>
+void Theme::PaintRadioControl(PaintBackendData& aPaintData,
+                              const LayoutDeviceRect& aRect,
+                              const ElementState& aState, const Colors& aColors,
+                              DPIRatio aDpiRatio) {
+  auto [backgroundColor, borderColor, checkColor] =
+      ComputeCheckboxColors(aState, StyleAppearance::Radio, aColors);
+  {
+    CSSCoord borderWidth = kCheckboxRadioBorderWidth;
+    if (backgroundColor == borderColor) {
+      borderWidth = 0.0f;
+    }
+    PaintStrokedCircle(aPaintData, aRect, backgroundColor, borderColor,
+                       borderWidth, aDpiRatio);
+  }
+
+  if (aState.HasState(ElementState::CHECKED)) {
+    LayoutDeviceRect rect(aRect);
+    auto width = LayoutDeviceCoord(
+        ThemeDrawing::SnapBorderWidth(kCheckboxRadioBorderWidth, aDpiRatio));
+    rect.Deflate(width);
+
+    PaintStrokedCircle(aPaintData, rect, backgroundColor, checkColor,
+                       kCheckboxRadioBorderWidth, aDpiRatio);
+  }
+
+  if (aState.HasState(ElementState::FOCUSRING)) {
+    PaintRoundedFocusRect(aPaintData, aRect, aColors, aDpiRatio, 5.0f, 1.0f);
+  }
+}
+
+template <typename PaintBackendData>
+void Theme::PaintTextField(PaintBackendData& aPaintData,
+                           const LayoutDeviceRect& aRect,
+                           const ElementState& aState, const Colors& aColors,
+                           DPIRatio aDpiRatio) {
+  auto [backgroundColor, borderColor] =
+      ComputeTextfieldColors(aState, aColors, OutlineCoversBorder::Yes);
+
+  const CSSCoord radius = 2.0f;
+
+  ThemeDrawing::PaintRoundedRectWithRadius(aPaintData, aRect, backgroundColor,
+                                           borderColor, kTextFieldBorderWidth,
+                                           radius, aDpiRatio);
+
+  if (aState.HasState(ElementState::FOCUSRING)) {
+    PaintRoundedFocusRect(aPaintData, aRect, aColors, aDpiRatio,
+                          radius + kTextFieldBorderWidth,
+                          -kTextFieldBorderWidth);
+  }
+}
+
+template <typename PaintBackendData>
+void Theme::PaintListbox(PaintBackendData& aPaintData,
+                         const LayoutDeviceRect& aRect,
+                         const ElementState& aState, const Colors& aColors,
+                         DPIRatio aDpiRatio) {
+  const CSSCoord radius = 2.0f;
+  auto [backgroundColor, borderColor] =
+      ComputeTextfieldColors(aState, aColors, OutlineCoversBorder::Yes);
+
+  ThemeDrawing::PaintRoundedRectWithRadius(aPaintData, aRect, backgroundColor,
+                                           borderColor, kMenulistBorderWidth,
+                                           radius, aDpiRatio);
+
+  if (aState.HasState(ElementState::FOCUSRING)) {
+    PaintRoundedFocusRect(aPaintData, aRect, aColors, aDpiRatio,
+                          radius + kMenulistBorderWidth, -kMenulistBorderWidth);
+  }
+}
+
+template <typename PaintBackendData>
+void Theme::PaintMenulist(PaintBackendData& aDrawTarget,
+                          const LayoutDeviceRect& aRect,
+                          const ElementState& aState, const Colors& aColors,
+                          DPIRatio aDpiRatio) {
+  const CSSCoord radius = 4.0f;
+  auto [backgroundColor, borderColor] = ComputeButtonColors(aState, aColors);
+
+  ThemeDrawing::PaintRoundedRectWithRadius(aDrawTarget, aRect, backgroundColor,
+                                           borderColor, kMenulistBorderWidth,
+                                           radius, aDpiRatio);
+
+  if (aState.HasState(ElementState::FOCUSRING)) {
+    PaintRoundedFocusRect(aDrawTarget, aRect, aColors, aDpiRatio,
+                          radius + kMenulistBorderWidth, -kMenulistBorderWidth);
+  }
+}
+
+void Theme::PaintMenulistArrowButton(nsIFrame* aFrame, DrawTarget& aDrawTarget,
+                                     const LayoutDeviceRect& aRect,
+                                     const ElementState& aState) {
+  // not const: these may be negated in-place below
+  float polygonX[] = {-4.0f, -0.5f, 0.5f, 4.0f,  4.0f,
+                      3.0f,  0.0f,  0.0f, -3.0f, -4.0f};
+  float polygonY[] = {-1,    3.0f, 3.0f, -1.0f, -2.0f,
+                      -2.0f, 1.5f, 1.5f, -2.0f, -2.0f};
+
+  const float kPolygonSize = kMinimumDropdownArrowButtonWidth;
+
+  auto const [xs, ys] = [&] {
+    using Pair = std::pair<const float*, const float*>;
+    switch (aFrame->GetWritingMode().GetBlockDir()) {
+      case WritingMode::BlockDir::eBlockRL:
+        // rotate 90°: [[0,1],[-1,0]]
+        for (float& f : polygonY) {
+          f = -f;
+        }
+        return Pair(polygonY, polygonX);
+
+      case WritingMode::BlockDir::eBlockLR:
+        // rotate 270°: [[0,-1],[1,0]]
+        for (float& f : polygonX) {
+          f = -f;
+        }
+        return Pair(polygonY, polygonX);
+
+      case WritingMode::BlockDir::eBlockTB:
+        // rotate 0°: [[1,0],[0,1]]
+        return Pair(polygonX, polygonY);
+    }
+    MOZ_ASSERT_UNREACHABLE("unhandled BlockDir");
+    return Pair(polygonX, polygonY);
+  }();
+
+  const auto arrowColor = sRGBColor::FromABGR(
+      nsLayoutUtils::GetColor(aFrame, &nsStyleText::mWebkitTextFillColor));
+  ThemeDrawing::PaintArrow(aDrawTarget, aRect, xs, ys, kPolygonSize,
+                           ArrayLength(polygonX), arrowColor);
+}
+
+void Theme::PaintSpinnerButton(nsIFrame* aFrame, DrawTarget& aDrawTarget,
+                               const LayoutDeviceRect& aRect,
+                               const ElementState& aState,
+                               StyleAppearance aAppearance,
+                               const Colors& aColors, DPIRatio aDpiRatio) {
+  auto [backgroundColor, borderColor] = ComputeButtonColors(aState, aColors);
+
+  aDrawTarget.FillRect(aRect.ToUnknownRect(),
+                       ColorPattern(ToDeviceColor(backgroundColor)));
+
+  const float kPolygonX[] = {-3.5f, -0.5f, 0.5f, 3.5f,  3.5f,
+                             2.5f,  0.0f,  0.0f, -2.5f, -3.5f};
+  float polygonY[] = {-1.5f, 1.5f, 1.5f, -1.5f, -2.5f,
+                      -2.5f, 0.0f, 0.0f, -2.5f, -2.5f};
+
+  const float kPolygonSize = kMinimumSpinnerButtonHeight;
+  if (aAppearance == StyleAppearance::SpinnerUpbutton) {
+    for (auto& coord : polygonY) {
+      coord = -coord;
+    }
+  }
+
+  ThemeDrawing::PaintArrow(aDrawTarget, aRect, kPolygonX, polygonY,
+                           kPolygonSize, ArrayLength(kPolygonX), borderColor);
+}
+
+template <typename PaintBackendData>
+void Theme::PaintRange(nsIFrame* aFrame, PaintBackendData& aPaintData,
+                       const LayoutDeviceRect& aRect,
+                       const ElementState& aState, const Colors& aColors,
+                       DPIRatio aDpiRatio, bool aHorizontal) {
+  nsRangeFrame* rangeFrame = do_QueryFrame(aFrame);
+  if (!rangeFrame) {
+    return;
+  }
+
+  auto tickMarks = rangeFrame->TickMarks();
+  double progress = rangeFrame->GetValueAsFractionOfRange();
+  auto rect = aRect;
+  LayoutDeviceRect thumbRect(0, 0, kMinimumRangeThumbSize * aDpiRatio,
+                             kMinimumRangeThumbSize * aDpiRatio);
+  LayoutDeviceRect progressClipRect(aRect);
+  LayoutDeviceRect trackClipRect(aRect);
+  const LayoutDeviceCoord verticalSize = kRangeHeight * aDpiRatio;
+  const LayoutDeviceCoord tickMarkWidth(
+      ThemeDrawing::SnapBorderWidth(1.0f, aDpiRatio));
+  const LayoutDeviceCoord tickMarkHeight(
+      ThemeDrawing::SnapBorderWidth(5.0f, aDpiRatio));
+  LayoutDevicePoint tickMarkOrigin, tickMarkDirection;
+  LayoutDeviceSize tickMarkSize;
+  if (aHorizontal) {
+    rect.height = verticalSize;
+    rect.y = aRect.y + (aRect.height - rect.height) / 2;
+    tickMarkSize = LayoutDeviceSize(tickMarkWidth, tickMarkHeight);
+    thumbRect.y = aRect.y + (aRect.height - thumbRect.height) / 2;
+
+    if (IsFrameRTL(aFrame)) {
+      tickMarkOrigin =
+          LayoutDevicePoint(aRect.XMost() - thumbRect.width / 2, aRect.YMost());
+      tickMarkDirection = LayoutDevicePoint(-1.0f, 0.0f);
+      thumbRect.x =
+          aRect.x + (aRect.width - thumbRect.width) * (1.0 - progress);
+      float midPoint = thumbRect.Center().X();
+      trackClipRect.SetBoxX(aRect.X(), midPoint);
+      progressClipRect.SetBoxX(midPoint, aRect.XMost());
+    } else {
+      tickMarkOrigin =
+          LayoutDevicePoint(aRect.x + thumbRect.width / 2, aRect.YMost());
+      tickMarkDirection = LayoutDevicePoint(1.0, 0.0f);
+      thumbRect.x = aRect.x + (aRect.width - thumbRect.width) * progress;
+      float midPoint = thumbRect.Center().X();
+      progressClipRect.SetBoxX(aRect.X(), midPoint);
+      trackClipRect.SetBoxX(midPoint, aRect.XMost());
+    }
+  } else {
+    rect.width = verticalSize;
+    rect.x = aRect.x + (aRect.width - rect.width) / 2;
+    tickMarkOrigin = LayoutDevicePoint(aRect.XMost() - tickMarkHeight / 4,
+                                       aRect.YMost() - thumbRect.width / 2);
+    tickMarkDirection = LayoutDevicePoint(0.0f, -1.0f);
+    tickMarkSize = LayoutDeviceSize(tickMarkHeight, tickMarkWidth);
+    thumbRect.x = aRect.x + (aRect.width - thumbRect.width) / 2;
+
+    thumbRect.y =
+        aRect.y + (aRect.height - thumbRect.height) * (1.0 - progress);
+    float midPoint = thumbRect.Center().Y();
+    trackClipRect.SetBoxY(aRect.Y(), midPoint);
+    progressClipRect.SetBoxY(midPoint, aRect.YMost());
+  }
+
+  const CSSCoord borderWidth = 1.0f;
+  const CSSCoord radius = 3.0f;
+
+  auto [progressColor, progressBorderColor] =
+      ComputeRangeProgressColors(aState, aColors);
+  auto [trackColor, trackBorderColor] =
+      ComputeRangeTrackColors(aState, aColors);
+  auto tickMarkColor = trackBorderColor;
+
+  ThemeDrawing::PaintRoundedRectWithRadius(aPaintData, rect, progressClipRect,
+                                           progressColor, progressBorderColor,
+                                           borderWidth, radius, aDpiRatio);
+
+  ThemeDrawing::PaintRoundedRectWithRadius(aPaintData, rect, trackClipRect,
+                                           trackColor, trackBorderColor,
+                                           borderWidth, radius, aDpiRatio);
+
+  if (!aState.HasState(ElementState::DISABLED)) {
+    // Ensure the shadow doesn't expand outside of our overflow rect declared in
+    // GetWidgetOverflow().
+    auto overflowRect = aRect;
+    overflowRect.Inflate(CSSCoord(6.0f) * aDpiRatio);
+    // Thumb shadow
+    PaintCircleShadow(aPaintData, thumbRect, overflowRect, 0.3f,
+                      CSSPoint(0.0f, 2.0f), 2.0f, aDpiRatio);
+  }
+
+  tickMarkDirection.x *= aRect.width - thumbRect.width;
+  tickMarkDirection.y *= aRect.height - thumbRect.height;
+  tickMarkOrigin -=
+      LayoutDevicePoint(tickMarkSize.width, tickMarkSize.height) / 2;
+  auto tickMarkRect = LayoutDeviceRect(tickMarkOrigin, tickMarkSize);
+  for (auto tickMark : tickMarks) {
+    auto tickMarkOffset =
+        tickMarkDirection *
+        float(rangeFrame->GetDoubleAsFractionOfRange(tickMark));
+    ThemeDrawing::FillRect(aPaintData, tickMarkRect + tickMarkOffset,
+                           tickMarkColor);
+  }
+
+  // Draw the thumb on top.
+  const CSSCoord thumbBorderWidth = 2.0f;
+  auto [thumbColor, thumbBorderColor] =
+      ComputeRangeThumbColors(aState, aColors);
+
+  PaintStrokedCircle(aPaintData, thumbRect, thumbColor, thumbBorderColor,
+                     thumbBorderWidth, aDpiRatio);
+
+  if (aState.HasState(ElementState::FOCUSRING)) {
+    PaintRoundedFocusRect(aPaintData, aRect, aColors, aDpiRatio, radius, 1.0f);
+  }
+}
+
+template <typename PaintBackendData>
+void Theme::PaintProgress(nsIFrame* aFrame, PaintBackendData& aPaintData,
+                          const LayoutDeviceRect& aRect,
+                          const ElementState& aState, const Colors& aColors,
+                          DPIRatio aDpiRatio, bool aIsMeter) {
+  const CSSCoord borderWidth = 1.0f;
+  const CSSCoord radius = aIsMeter ? 6.0f : 3.0f;
+
+  LayoutDeviceRect rect(aRect);
+  const LayoutDeviceCoord thickness =
+      (aIsMeter ? kMeterHeight : kProgressbarHeight) * aDpiRatio;
+
+  const bool isHorizontal = !nsNativeTheme::IsVerticalProgress(aFrame);
+  if (isHorizontal) {
+    // Center it vertically.
+    rect.y += (rect.height - thickness) / 2;
+    rect.height = thickness;
+  } else {
+    // Center it horizontally.
+    rect.x += (rect.width - thickness) / 2;
+    rect.width = thickness;
+  }
+
+  {
+    // Paint the track, unclipped.
+    auto [backgroundColor, borderColor] = ComputeProgressTrackColors(aColors);
+    ThemeDrawing::PaintRoundedRectWithRadius(aPaintData, rect, rect,
+                                             backgroundColor, borderColor,
+                                             borderWidth, radius, aDpiRatio);
+  }
+
+  // Now paint the chunk, clipped as needed.
+  LayoutDeviceRect clipRect = rect;
+  if (aState.HasState(ElementState::INDETERMINATE)) {
+    // For indeterminate progress, we paint an animated chunk of 1/3 of the
+    // progress size.
+    //
+    // Animation speed and math borrowed from GTK.
+    const LayoutDeviceCoord size = isHorizontal ? rect.width : rect.height;
+    const LayoutDeviceCoord barSize = size * 0.3333f;
+    const LayoutDeviceCoord travel = 2.0f * (size - barSize);
+
+    // Period equals to travel / pixelsPerMillisecond where pixelsPerMillisecond
+    // equals progressSize / 1000.0.  This is equivalent to 1600.
+    const unsigned kPeriod = 1600;
+
+    const int t = PR_IntervalToMilliseconds(PR_IntervalNow()) % kPeriod;
+    const LayoutDeviceCoord dx = travel * float(t) / float(kPeriod);
+    if (isHorizontal) {
+      rect.width = barSize;
+      rect.x += (dx < travel * .5f) ? dx : travel - dx;
+    } else {
+      rect.height = barSize;
+      rect.y += (dx < travel * .5f) ? dx : travel - dx;
+    }
+    clipRect = rect;
+    // Queue the next frame if needed.
+    if (!QueueAnimatedContentForRefresh(aFrame->GetContent(), 60)) {
+      NS_WARNING("Couldn't refresh indeterminate <progress>");
+    }
+  } else {
+    // This is the progress chunk, clip it to the right amount.
+    double position = [&] {
+      if (aIsMeter) {
+        auto* meter = dom::HTMLMeterElement::FromNode(aFrame->GetContent());
+        if (!meter) {
+          return 0.0;
+        }
+        return meter->Position();
+      }
+      auto* progress = dom::HTMLProgressElement::FromNode(aFrame->GetContent());
+      if (!progress) {
+        return 0.0;
+      }
+      return progress->Position();
+    }();
+    if (isHorizontal) {
+      double clipWidth = rect.width * position;
+      clipRect.width = clipWidth;
+      if (IsFrameRTL(aFrame)) {
+        clipRect.x += rect.width - clipWidth;
+      }
+    } else {
+      double clipHeight = rect.height * position;
+      clipRect.height = clipHeight;
+      clipRect.y += rect.height - clipHeight;
+    }
+  }
+
+  auto [backgroundColor, borderColor] =
+      aIsMeter ? ComputeMeterchunkColors(aState, aColors)
+               : ComputeProgressColors(aColors);
+  ThemeDrawing::PaintRoundedRectWithRadius(aPaintData, rect, clipRect,
+                                           backgroundColor, borderColor,
+                                           borderWidth, radius, aDpiRatio);
+}
+
+template <typename PaintBackendData>
+void Theme::PaintButton(nsIFrame* aFrame, PaintBackendData& aPaintData,
+                        const LayoutDeviceRect& aRect,
+                        const ElementState& aState, const Colors& aColors,
+                        DPIRatio aDpiRatio) {
+  const CSSCoord radius = 4.0f;
+  auto [backgroundColor, borderColor] =
+      ComputeButtonColors(aState, aColors, aFrame);
+
+  ThemeDrawing::PaintRoundedRectWithRadius(aPaintData, aRect, backgroundColor,
+                                           borderColor, kButtonBorderWidth,
+                                           radius, aDpiRatio);
+
+  if (aState.HasState(ElementState::FOCUSRING)) {
+    PaintRoundedFocusRect(aPaintData, aRect, aColors, aDpiRatio,
+                          radius + kButtonBorderWidth, -kButtonBorderWidth);
+  }
+}
+
+NS_IMETHODIMP
+Theme::DrawWidgetBackground(gfxContext* aContext, nsIFrame* aFrame,
+                            StyleAppearance aAppearance, const nsRect& aRect,
+                            const nsRect& /* aDirtyRect */,
+                            DrawOverflow aDrawOverflow) {
+  if (!DoDrawWidgetBackground(*aContext->GetDrawTarget(), aFrame, aAppearance,
+                              aRect, aDrawOverflow)) {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+  return NS_OK;
+}
+
+bool Theme::CreateWebRenderCommandsForWidget(
+    mozilla::wr::DisplayListBuilder& aBuilder,
+    mozilla::wr::IpcResourceUpdateQueue& aResources,
+    const mozilla::layers::StackingContextHelper& aSc,
+    mozilla::layers::RenderRootStateManager* aManager, nsIFrame* aFrame,
+    StyleAppearance aAppearance, const nsRect& aRect) {
+  if (!StaticPrefs::widget_non_native_theme_webrender()) {
+    return false;
+  }
+  WebRenderBackendData data{aBuilder, aResources, aSc, aManager};
+  return DoDrawWidgetBackground(data, aFrame, aAppearance, aRect,
+                                DrawOverflow::Yes);
+}
+
+static LayoutDeviceRect ToSnappedRect(const nsRect& aRect,
+                                      nscoord aTwipsPerPixel, DrawTarget& aDt) {
+  return LayoutDeviceRect::FromUnknownRect(
+      NSRectToSnappedRect(aRect, aTwipsPerPixel, aDt));
+}
+
+static LayoutDeviceRect ToSnappedRect(const nsRect& aRect,
+                                      nscoord aTwipsPerPixel,
+                                      WebRenderBackendData& aDt) {
+  // TODO: Do we need to do any more snapping here?
+  return LayoutDeviceRect::FromAppUnits(aRect, aTwipsPerPixel);
+}
+
+static ScrollbarDrawing::ScrollbarKind ComputeScrollbarKind(
+    nsIFrame* aFrame, bool aIsHorizontal) {
+  if (aIsHorizontal) {
+    return ScrollbarDrawing::ScrollbarKind::Horizontal;
+  }
+  nsIFrame* scrollbar = ScrollbarDrawing::GetParentScrollbarFrame(aFrame);
+  if (NS_WARN_IF(!scrollbar)) {
+    return ScrollbarDrawing::ScrollbarKind::VerticalRight;
+  }
+  MOZ_ASSERT(scrollbar->IsScrollbarFrame());
+  nsIScrollbarMediator* sm =
+      static_cast<nsScrollbarFrame*>(scrollbar)->GetScrollbarMediator();
+  if (NS_WARN_IF(!sm)) {
+    return ScrollbarDrawing::ScrollbarKind::VerticalRight;
+  }
+  return sm->IsScrollbarOnRight()
+             ? ScrollbarDrawing::ScrollbarKind::VerticalRight
+             : ScrollbarDrawing::ScrollbarKind::VerticalLeft;
+}
+
+template <typename PaintBackendData>
+bool Theme::DoDrawWidgetBackground(PaintBackendData& aPaintData,
+                                   nsIFrame* aFrame,
+                                   StyleAppearance aAppearance,
+                                   const nsRect& aRect,
+                                   DrawOverflow aDrawOverflow) {
+  static_assert(std::is_same_v<PaintBackendData, DrawTarget> ||
+                std::is_same_v<PaintBackendData, WebRenderBackendData>);
+
+  const nsPresContext* pc = aFrame->PresContext();
+  const nscoord twipsPerPixel = pc->AppUnitsPerDevPixel();
+  const auto devPxRect = ToSnappedRect(aRect, twipsPerPixel, aPaintData);
+
+  const DocumentState docState = pc->Document()->GetDocumentState();
+  ElementState elementState = GetContentState(aFrame, aAppearance);
+  if (aAppearance == StyleAppearance::MozMenulistArrowButton) {
+    // HTML select and XUL menulist dropdown buttons get state from the
+    // parent.
+    nsIFrame* parentFrame = aFrame->GetParent();
+    aFrame = parentFrame;
+    elementState = GetContentState(parentFrame, aAppearance);
+  }
+
+  // Paint the outline iff we're asked to draw overflow and we have
+  // outline-style: auto.
+  if (aDrawOverflow == DrawOverflow::Yes &&
+      aFrame->StyleOutline()->mOutlineStyle.IsAuto()) {
+    elementState |= ElementState::FOCUSRING;
+  } else {
+    elementState &= ~ElementState::FOCUSRING;
+  }
+
+  // Hack to avoid skia fuzziness: Add a dummy clip if the widget doesn't
+  // overflow devPxRect.
+  Maybe<AutoClipRect> maybeClipRect;
+  if constexpr (std::is_same_v<PaintBackendData, DrawTarget>) {
+    if (aAppearance != StyleAppearance::FocusOutline &&
+        aAppearance != StyleAppearance::Range &&
+        !elementState.HasState(ElementState::FOCUSRING)) {
+      maybeClipRect.emplace(aPaintData, devPxRect);
+    }
+  }
+
+  const Colors colors(aFrame, aAppearance);
+  DPIRatio dpiRatio = GetDPIRatio(aFrame, aAppearance);
+
+  switch (aAppearance) {
+    case StyleAppearance::Radio: {
+      auto rect = CheckBoxRadioRect(devPxRect);
+      PaintRadioControl(aPaintData, rect, elementState, colors, dpiRatio);
+      break;
+    }
+    case StyleAppearance::Checkbox: {
+      if constexpr (std::is_same_v<PaintBackendData, WebRenderBackendData>) {
+        // TODO: Need to figure out how to best draw this using WR.
+        return false;
+      } else {
+        auto rect = CheckBoxRadioRect(devPxRect);
+        PaintCheckboxControl(aPaintData, rect, elementState, colors, dpiRatio);
+      }
+      break;
+    }
+    case StyleAppearance::Textarea:
+    case StyleAppearance::Textfield:
+    case StyleAppearance::NumberInput:
+      PaintTextField(aPaintData, devPxRect, elementState, colors, dpiRatio);
+      break;
+    case StyleAppearance::Listbox:
+      PaintListbox(aPaintData, devPxRect, elementState, colors, dpiRatio);
+      break;
+    case StyleAppearance::MenulistButton:
+    case StyleAppearance::Menulist:
+      PaintMenulist(aPaintData, devPxRect, elementState, colors, dpiRatio);
+      break;
+    case StyleAppearance::MozMenulistArrowButton:
+      if constexpr (std::is_same_v<PaintBackendData, WebRenderBackendData>) {
+        // TODO: Need to figure out how to best draw this using WR.
+        return false;
+      } else {
+        PaintMenulistArrowButton(aFrame, aPaintData, devPxRect, elementState);
+      }
+      break;
+    case StyleAppearance::Tooltip: {
+      const CSSCoord strokeWidth(1.0f);
+      const CSSCoord strokeRadius(2.0f);
+      ThemeDrawing::PaintRoundedRectWithRadius(
+          aPaintData, devPxRect,
+          colors.System(StyleSystemColor::Infobackground),
+          colors.System(StyleSystemColor::Infotext), strokeWidth, strokeRadius,
+          dpiRatio);
+      break;
+    }
+    case StyleAppearance::Menuitem: {
+      ThemeDrawing::FillRect(aPaintData, devPxRect, [&] {
+        if (CheckBooleanAttr(aFrame, nsGkAtoms::menuactive)) {
+          if (elementState.HasState(ElementState::DISABLED)) {
+            return colors.System(StyleSystemColor::MozMenuhoverdisabled);
+          }
+          return colors.System(StyleSystemColor::MozMenuhover);
+        }
+        return sTransparent;
+      }());
+      break;
+    }
+    case StyleAppearance::SpinnerUpbutton:
+    case StyleAppearance::SpinnerDownbutton:
+      if constexpr (std::is_same_v<PaintBackendData, WebRenderBackendData>) {
+        // TODO: Need to figure out how to best draw this using WR.
+        return false;
+      } else {
+        PaintSpinnerButton(aFrame, aPaintData, devPxRect, elementState,
+                           aAppearance, colors, dpiRatio);
+      }
+      break;
+    case StyleAppearance::Range:
+      PaintRange(aFrame, aPaintData, devPxRect, elementState, colors, dpiRatio,
+                 IsRangeHorizontal(aFrame));
+      break;
+    case StyleAppearance::RangeThumb:
+      // Painted as part of StyleAppearance::Range.
+      break;
+    case StyleAppearance::ProgressBar:
+      PaintProgress(aFrame, aPaintData, devPxRect, elementState, colors,
+                    dpiRatio,
+                    /* aIsMeter = */ false);
+      break;
+    case StyleAppearance::Progresschunk:
+      /* Painted as part of the progress bar */
+      break;
+    case StyleAppearance::Meter:
+      PaintProgress(aFrame, aPaintData, devPxRect, elementState, colors,
+                    dpiRatio,
+                    /* aIsMeter = */ true);
+      break;
+    case StyleAppearance::Meterchunk:
+      /* Painted as part of the meter bar */
+      break;
+    case StyleAppearance::ScrollbarthumbHorizontal:
+    case StyleAppearance::ScrollbarthumbVertical: {
+      bool isHorizontal =
+          aAppearance == StyleAppearance::ScrollbarthumbHorizontal;
+      auto kind = ComputeScrollbarKind(aFrame, isHorizontal);
+      return GetScrollbarDrawing().PaintScrollbarThumb(
+          aPaintData, devPxRect, kind, aFrame,
+          *nsLayoutUtils::StyleForScrollbar(aFrame), elementState, docState,
+          colors, dpiRatio);
+    }
+    case StyleAppearance::ScrollbartrackHorizontal:
+    case StyleAppearance::ScrollbartrackVertical: {
+      bool isHorizontal =
+          aAppearance == StyleAppearance::ScrollbartrackHorizontal;
+      auto kind = ComputeScrollbarKind(aFrame, isHorizontal);
+      return GetScrollbarDrawing().PaintScrollbarTrack(
+          aPaintData, devPxRect, kind, aFrame,
+          *nsLayoutUtils::StyleForScrollbar(aFrame), docState, colors,
+          dpiRatio);
+    }
+    case StyleAppearance::ScrollbarHorizontal:
+    case StyleAppearance::ScrollbarVertical: {
+      bool isHorizontal = aAppearance == StyleAppearance::ScrollbarHorizontal;
+      auto kind = ComputeScrollbarKind(aFrame, isHorizontal);
+      return GetScrollbarDrawing().PaintScrollbar(
+          aPaintData, devPxRect, kind, aFrame,
+          *nsLayoutUtils::StyleForScrollbar(aFrame), elementState, docState,
+          colors, dpiRatio);
+    }
+    case StyleAppearance::Scrollcorner: {
+      auto kind = ComputeScrollbarKind(aFrame, false);
+      return GetScrollbarDrawing().PaintScrollCorner(
+          aPaintData, devPxRect, kind, aFrame,
+          *nsLayoutUtils::StyleForScrollbar(aFrame), docState, colors,
+          dpiRatio);
+    }
+    case StyleAppearance::ScrollbarbuttonUp:
+    case StyleAppearance::ScrollbarbuttonDown:
+    case StyleAppearance::ScrollbarbuttonLeft:
+    case StyleAppearance::ScrollbarbuttonRight: {
+      // For scrollbar-width:thin, we don't display the buttons.
+      if (!ScrollbarDrawing::IsScrollbarWidthThin(aFrame)) {
+        if constexpr (std::is_same_v<PaintBackendData, WebRenderBackendData>) {
+          // TODO: Need to figure out how to best draw this using WR.
+          return false;
+        } else {
+          bool isHorizontal =
+              aAppearance == StyleAppearance::ScrollbarbuttonLeft ||
+              aAppearance == StyleAppearance::ScrollbarbuttonRight;
+          auto kind = ComputeScrollbarKind(aFrame, isHorizontal);
+          GetScrollbarDrawing().PaintScrollbarButton(
+              aPaintData, aAppearance, devPxRect, kind, aFrame,
+              *nsLayoutUtils::StyleForScrollbar(aFrame), elementState, docState,
+              colors, dpiRatio);
+        }
+      }
+      break;
+    }
+    case StyleAppearance::Button:
+      PaintButton(aFrame, aPaintData, devPxRect, elementState, colors,
+                  dpiRatio);
+      break;
+    case StyleAppearance::FocusOutline:
+      PaintAutoStyleOutline(aFrame, aPaintData, devPxRect, colors, dpiRatio);
+      break;
+    default:
+      // Various appearance values are used for XUL elements.  Normally these
+      // will not be available in content documents (and thus in the content
+      // processes where the native basic theme can be used), but tests are
+      // run with the remote XUL pref enabled and so we can get in here.  So
+      // we just return an error rather than assert.
+      return false;
+  }
+
+  return true;
+}
+
+template <typename PaintBackendData>
+void Theme::PaintAutoStyleOutline(nsIFrame* aFrame,
+                                  PaintBackendData& aPaintData,
+                                  const LayoutDeviceRect& aRect,
+                                  const Colors& aColors, DPIRatio aDpiRatio) {
+  const auto& accentColor = aColors.Accent();
+  const bool solid = StaticPrefs::widget_non_native_theme_solid_outline_style();
+  LayoutDeviceCoord strokeWidth(ThemeDrawing::SnapBorderWidth(2.0f, aDpiRatio));
+
+  LayoutDeviceRect rect(aRect);
+  rect.Inflate(strokeWidth);
+
+  const nscoord a2d = aFrame->PresContext()->AppUnitsPerDevPixel();
+  nscoord cssOffset = aFrame->StyleOutline()->mOutlineOffset.ToAppUnits();
+  nscoord cssRadii[8] = {0};
+  if (!aFrame->GetBorderRadii(cssRadii)) {
+    const auto twoPixels = 2 * AppUnitsPerCSSPixel();
+    const nscoord radius =
+        cssOffset >= 0 ? twoPixels : std::max(twoPixels + cssOffset, 0);
+    cssOffset = -twoPixels;
+    for (auto& r : cssRadii) {
+      r = radius;
+    }
+  }
+
+  auto offset = LayoutDevicePixel::FromAppUnits(cssOffset, a2d);
+  RectCornerRadii innerRadii;
+  nsCSSRendering::ComputePixelRadii(cssRadii, a2d, &innerRadii);
+
+  // NOTE(emilio): This doesn't use PaintRoundedRectWithRadius because we need
+  // to support arbitrary radii.
+  auto DrawRect = [&](const sRGBColor& aColor) {
+    RectCornerRadii outerRadii;
+    if constexpr (std::is_same_v<PaintBackendData, WebRenderBackendData>) {
+      const Float widths[4] = {strokeWidth + offset, strokeWidth + offset,
+                               strokeWidth + offset, strokeWidth + offset};
+      nsCSSBorderRenderer::ComputeOuterRadii(innerRadii, widths, &outerRadii);
+      const auto dest = wr::ToLayoutRect(rect);
+      const auto side =
+          wr::ToBorderSide(ToDeviceColor(aColor), StyleBorderStyle::Solid);
+      const wr::BorderSide sides[4] = {side, side, side, side};
+      const bool kBackfaceIsVisible = true;
+      const auto wrWidths = wr::ToBorderWidths(strokeWidth, strokeWidth,
+                                               strokeWidth, strokeWidth);
+      const auto wrRadius = wr::ToBorderRadius(outerRadii);
+      aPaintData.mBuilder.PushBorder(dest, dest, kBackfaceIsVisible, wrWidths,
+                                     {sides, 4}, wrRadius);
+    } else {
+      const LayoutDeviceCoord halfWidth = strokeWidth * 0.5f;
+      const Float widths[4] = {halfWidth + offset, halfWidth + offset,
+                               halfWidth + offset, halfWidth + offset};
+      nsCSSBorderRenderer::ComputeOuterRadii(innerRadii, widths, &outerRadii);
+      LayoutDeviceRect dest(rect);
+      dest.Deflate(halfWidth);
+      RefPtr<Path> path =
+          MakePathForRoundedRect(aPaintData, dest.ToUnknownRect(), outerRadii);
+      aPaintData.Stroke(path, ColorPattern(ToDeviceColor(aColor)),
+                        StrokeOptions(strokeWidth));
+    }
+  };
+
+  DrawRect(accentColor.Get());
+
+  if (solid) {
+    return;
+  }
+
+  offset += strokeWidth;
+
+  strokeWidth =
+      LayoutDeviceCoord(ThemeDrawing::SnapBorderWidth(1.0f, aDpiRatio));
+  rect.Inflate(strokeWidth);
+
+  DrawRect(accentColor.GetForeground());
+}
+
+LayoutDeviceIntMargin Theme::GetWidgetBorder(nsDeviceContext* aContext,
+                                             nsIFrame* aFrame,
+                                             StyleAppearance aAppearance) {
+  switch (aAppearance) {
+    case StyleAppearance::Textfield:
+    case StyleAppearance::Textarea:
+    case StyleAppearance::NumberInput:
+    case StyleAppearance::Listbox:
+    case StyleAppearance::Menulist:
+    case StyleAppearance::MenulistButton:
+    case StyleAppearance::Button:
+      // Return the border size from the UA sheet, even though what we paint
+      // doesn't actually match that. We know this is the UA sheet border
+      // because we disable native theming when different border widths are
+      // specified by authors, see Theme::IsWidgetStyled.
+      //
+      // The Rounded() bit is technically redundant, but needed to appease the
+      // type system, we should always end up with full device pixels due to
+      // round_border_to_device_pixels at style time.
+      return LayoutDeviceIntMargin::FromAppUnits(
+                 aFrame->StyleBorder()->GetComputedBorder(),
+                 aFrame->PresContext()->AppUnitsPerDevPixel())
+          .Rounded();
+    case StyleAppearance::Checkbox:
+    case StyleAppearance::Radio: {
+      DPIRatio dpiRatio = GetDPIRatio(aFrame, aAppearance);
+      LayoutDeviceIntCoord w =
+          ThemeDrawing::SnapBorderWidth(kCheckboxRadioBorderWidth, dpiRatio);
+      return LayoutDeviceIntMargin(w, w, w, w);
+    }
+    default:
+      return LayoutDeviceIntMargin();
+  }
+}
+
+bool Theme::GetWidgetPadding(nsDeviceContext* aContext, nsIFrame* aFrame,
+                             StyleAppearance aAppearance,
+                             LayoutDeviceIntMargin* aResult) {
+  switch (aAppearance) {
+    // Radios and checkboxes return a fixed size in GetMinimumWidgetSize
+    // and have a meaningful baseline, so they can't have
+    // author-specified padding.
+    case StyleAppearance::Radio:
+    case StyleAppearance::Checkbox:
+      aResult->SizeTo(0, 0, 0, 0);
+      return true;
+    default:
+      break;
+  }
+  return false;
+}
+
+bool Theme::GetWidgetOverflow(nsDeviceContext* aContext, nsIFrame* aFrame,
+                              StyleAppearance aAppearance,
+                              nsRect* aOverflowRect) {
+  CSSIntMargin overflow;
+  switch (aAppearance) {
+    case StyleAppearance::FocusOutline: {
+      // 2px * one segment, or 2px + 1px
+      const auto width =
+          StaticPrefs::widget_non_native_theme_solid_outline_style() ? 2 : 3;
+      overflow.SizeTo(width, width, width, width);
+      break;
+    }
+    case StyleAppearance::Radio:
+    case StyleAppearance::Checkbox:
+    case StyleAppearance::Range:
+      // 2px for each outline segment, plus 1px separation, plus we paint with a
+      // 1px extra offset, so 6px.
+      overflow.SizeTo(6, 6, 6, 6);
+      break;
+    case StyleAppearance::Textarea:
+    case StyleAppearance::Textfield:
+    case StyleAppearance::NumberInput:
+    case StyleAppearance::Listbox:
+    case StyleAppearance::MenulistButton:
+    case StyleAppearance::Menulist:
+    case StyleAppearance::Button:
+      // 2px for each segment, plus 1px separation, but we paint 1px inside
+      // the border area so 4px overflow.
+      overflow.SizeTo(4, 4, 4, 4);
+      break;
+    default:
+      return false;
+  }
+
+  // TODO: This should convert from device pixels to app units, not from CSS
+  // pixels. And it should take the dpi ratio into account.
+  // Using CSS pixels can cause the overflow to be too small if the page is
+  // zoomed out.
+  aOverflowRect->Inflate(CSSPixel::ToAppUnits(overflow));
+  return true;
+}
+
+auto Theme::GetScrollbarSizes(nsPresContext* aPresContext,
+                              StyleScrollbarWidth aWidth, Overlay aOverlay)
+    -> ScrollbarSizes {
+  return GetScrollbarDrawing().GetScrollbarSizes(aPresContext, aWidth,
+                                                 aOverlay);
+}
+
+nscoord Theme::GetCheckboxRadioPrefSize() {
+  return CSSPixel::ToAppUnits(kCheckboxRadioContentBoxSize);
+}
+
+/* static */
+UniquePtr<ScrollbarDrawing> Theme::ScrollbarStyle() {
+  switch (StaticPrefs::widget_non_native_theme_scrollbar_style()) {
+    case 1:
+      return MakeUnique<ScrollbarDrawingCocoa>();
+    case 2:
+      return MakeUnique<ScrollbarDrawingGTK>();
+    case 3:
+      return MakeUnique<ScrollbarDrawingAndroid>();
+    case 4:
+      return MakeUnique<ScrollbarDrawingWin>();
+    case 5:
+      return MakeUnique<ScrollbarDrawingWin11>();
+    default:
+      break;
+  }
+    // Default to native scrollbar style for each platform.
+#ifdef XP_WIN
+  if (IsWin11OrLater()) {
+    return MakeUnique<ScrollbarDrawingWin11>();
+  }
+  return MakeUnique<ScrollbarDrawingWin>();
+#elif MOZ_WIDGET_COCOA
+  return MakeUnique<ScrollbarDrawingCocoa>();
+#elif MOZ_WIDGET_GTK
+  return MakeUnique<ScrollbarDrawingGTK>();
+#elif ANDROID
+  return MakeUnique<ScrollbarDrawingAndroid>();
+#else
+#  error "Unknown platform, need scrollbar implementation."
+#endif
+}
+
+LayoutDeviceIntSize Theme::GetMinimumWidgetSize(nsPresContext* aPresContext,
+                                                nsIFrame* aFrame,
+                                                StyleAppearance aAppearance) {
+  DPIRatio dpiRatio = GetDPIRatio(aFrame, aAppearance);
+
+  if (IsWidgetScrollbarPart(aAppearance)) {
+    return GetScrollbarDrawing().GetMinimumWidgetSize(aPresContext, aAppearance,
+                                                      aFrame);
+  }
+
+  LayoutDeviceIntSize result;
+  switch (aAppearance) {
+    case StyleAppearance::RangeThumb:
+      result.SizeTo((kMinimumRangeThumbSize * dpiRatio).Rounded(),
+                    (kMinimumRangeThumbSize * dpiRatio).Rounded());
+      break;
+    case StyleAppearance::MozMenulistArrowButton:
+      result.width = (kMinimumDropdownArrowButtonWidth * dpiRatio).Rounded();
+      break;
+    case StyleAppearance::SpinnerUpbutton:
+    case StyleAppearance::SpinnerDownbutton:
+      result.width = (kMinimumSpinnerButtonWidth * dpiRatio).Rounded();
+      result.height = (kMinimumSpinnerButtonHeight * dpiRatio).Rounded();
+      break;
+    default:
+      break;
+  }
+  return result;
+}
+
+nsITheme::Transparency Theme::GetWidgetTransparency(
+    nsIFrame* aFrame, StyleAppearance aAppearance) {
+  if (auto scrollbar = GetScrollbarDrawing().GetScrollbarPartTransparency(
+          aFrame, aAppearance)) {
+    return *scrollbar;
+  }
+  if (aAppearance == StyleAppearance::Tooltip) {
+    // We draw a rounded rect, so we need transparency.
+    return eTransparent;
+  }
+  return eUnknownTransparency;
+}
+
+NS_IMETHODIMP
+Theme::WidgetStateChanged(nsIFrame* aFrame, StyleAppearance aAppearance,
+                          nsAtom* aAttribute, bool* aShouldRepaint,
+                          const nsAttrValue* aOldValue) {
+  if (!aAttribute) {
+    // Hover/focus/active changed.  Always repaint.
+    *aShouldRepaint = true;
+  } else {
+    // Check the attribute to see if it's relevant.
+    // disabled, checked, dlgtype, default, etc.
+    *aShouldRepaint = false;
+    if (aAttribute == nsGkAtoms::disabled || aAttribute == nsGkAtoms::checked ||
+        aAttribute == nsGkAtoms::selected ||
+        aAttribute == nsGkAtoms::visuallyselected ||
+        aAttribute == nsGkAtoms::menuactive ||
+        aAttribute == nsGkAtoms::sortDirection ||
+        aAttribute == nsGkAtoms::focused || aAttribute == nsGkAtoms::_default ||
+        aAttribute == nsGkAtoms::open || aAttribute == nsGkAtoms::hover) {
+      *aShouldRepaint = true;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Theme::ThemeChanged() { return NS_OK; }
+
+bool Theme::WidgetAppearanceDependsOnWindowFocus(StyleAppearance aAppearance) {
+  return IsWidgetScrollbarPart(aAppearance);
+}
+
+nsITheme::ThemeGeometryType Theme::ThemeGeometryTypeForWidget(
+    nsIFrame* aFrame, StyleAppearance aAppearance) {
+  return eThemeGeometryTypeUnknown;
+}
+
+bool Theme::ThemeSupportsWidget(nsPresContext* aPresContext, nsIFrame* aFrame,
+                                StyleAppearance aAppearance) {
+  switch (aAppearance) {
+    case StyleAppearance::Radio:
+    case StyleAppearance::Checkbox:
+    case StyleAppearance::FocusOutline:
+    case StyleAppearance::Textarea:
+    case StyleAppearance::Textfield:
+    case StyleAppearance::Range:
+    case StyleAppearance::RangeThumb:
+    case StyleAppearance::ProgressBar:
+    case StyleAppearance::Progresschunk:
+    case StyleAppearance::Meter:
+    case StyleAppearance::Meterchunk:
+    case StyleAppearance::ScrollbarbuttonUp:
+    case StyleAppearance::ScrollbarbuttonDown:
+    case StyleAppearance::ScrollbarbuttonLeft:
+    case StyleAppearance::ScrollbarbuttonRight:
+    case StyleAppearance::ScrollbarthumbHorizontal:
+    case StyleAppearance::ScrollbarthumbVertical:
+    case StyleAppearance::ScrollbartrackHorizontal:
+    case StyleAppearance::ScrollbartrackVertical:
+    case StyleAppearance::ScrollbarHorizontal:
+    case StyleAppearance::ScrollbarVertical:
+    case StyleAppearance::Scrollcorner:
+    case StyleAppearance::Button:
+    case StyleAppearance::Listbox:
+    case StyleAppearance::Menulist:
+    case StyleAppearance::MenulistButton:
+    case StyleAppearance::NumberInput:
+    case StyleAppearance::MozMenulistArrowButton:
+    case StyleAppearance::SpinnerUpbutton:
+    case StyleAppearance::SpinnerDownbutton:
+    case StyleAppearance::Menuitem:
+    case StyleAppearance::Tooltip:
+      return !IsWidgetStyled(aPresContext, aFrame, aAppearance);
+    default:
+      return false;
+  }
+}
+
+bool Theme::WidgetIsContainer(StyleAppearance aAppearance) {
+  switch (aAppearance) {
+    case StyleAppearance::MozMenulistArrowButton:
+    case StyleAppearance::Radio:
+    case StyleAppearance::Checkbox:
+      return false;
+    default:
+      return true;
+  }
+}
+
+bool Theme::ThemeDrawsFocusForWidget(nsIFrame*, StyleAppearance) {
+  return true;
+}
+
+bool Theme::ThemeNeedsComboboxDropmarker() { return true; }
+
+bool Theme::ThemeSupportsScrollbarButtons() {
+  return GetScrollbarDrawing().ShouldDrawScrollbarButtons();
+}
+
+}  // namespace mozilla::widget