Bug 1561491 - Make general.* static prefs follow the naming convention. r=KrisWright
authorNicholas Nethercote <nnethercote@mozilla.com>
Tue, 25 Jun 2019 17:07:57 +1000
changeset 543145 b82272f67e6fb1e751edf6ccc95925b251cd9140
parent 543144 cb0e343c1b2cd9148e96458bdf893bb54fdcc7d3
child 543146 52f6453da5d633c17d63b0b867e83a61071c0001
push id2131
push userffxbld-merge
push dateMon, 26 Aug 2019 18:30:20 +0000
treeherdermozilla-release@b19ffb3ca153 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersKrisWright
bugs1561491
milestone69.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1561491 - Make general.* static prefs follow the naming convention. r=KrisWright Differential Revision: https://phabricator.services.mozilla.com/D35974
gfx/layers/apz/src/APZInputBridge.cpp
gfx/layers/apz/src/AsyncPanZoomController.cpp
gfx/layers/apz/src/GenericScrollAnimation.cpp
gfx/layers/apz/src/KeyboardScrollAnimation.cpp
gfx/layers/apz/src/WheelScrollAnimation.cpp
layout/generic/ScrollAnimationBezierPhysics.cpp
layout/generic/ScrollAnimationMSDPhysics.cpp
layout/generic/nsGfxScrollFrame.cpp
modules/libpref/init/StaticPrefList.h
widget/cocoa/nsChildView.mm
--- a/gfx/layers/apz/src/APZInputBridge.cpp
+++ b/gfx/layers/apz/src/APZInputBridge.cpp
@@ -110,23 +110,23 @@ nsEventStatus APZInputBridge::ReceiveInp
       return result;
     }
     case eWheelEventClass: {
       WidgetWheelEvent& wheelEvent = *aEvent.AsWheelEvent();
 
       if (Maybe<APZWheelAction> action = ActionForWheelEvent(&wheelEvent)) {
         ScrollWheelInput::ScrollMode scrollMode =
             ScrollWheelInput::SCROLLMODE_INSTANT;
-        if (StaticPrefs::SmoothScrollEnabled() &&
+        if (StaticPrefs::general_smoothScroll() &&
             ((wheelEvent.mDeltaMode ==
                   dom::WheelEvent_Binding::DOM_DELTA_LINE &&
-              StaticPrefs::WheelSmoothScrollEnabled()) ||
+              StaticPrefs::general_smoothScroll_mouseWheel()) ||
              (wheelEvent.mDeltaMode ==
                   dom::WheelEvent_Binding::DOM_DELTA_PAGE &&
-              StaticPrefs::PageSmoothScrollEnabled()))) {
+              StaticPrefs::general_smoothScroll_pages()))) {
           scrollMode = ScrollWheelInput::SCROLLMODE_SMOOTH;
         }
 
         WheelDeltaAdjustmentStrategy strategy =
             EventStateManager::GetWheelDeltaAdjustmentStrategy(wheelEvent);
         // Adjust the delta values of the wheel event if the current default
         // action is to horizontalize scrolling. I.e., deltaY values are set to
         // deltaX and deltaY and deltaZ values are set to 0.
--- a/gfx/layers/apz/src/AsyncPanZoomController.cpp
+++ b/gfx/layers/apz/src/AsyncPanZoomController.cpp
@@ -2007,17 +2007,17 @@ nsEventStatus AsyncPanZoomController::On
   mTestHasAsyncKeyScrolled = true;
 
   // Calculate the destination for this keyboard scroll action
   CSSPoint destination = GetKeyboardDestination(aEvent.mAction);
   bool scrollSnapped =
       MaybeAdjustDestinationForScrollSnapping(aEvent, destination);
 
   // If smooth scrolling is disabled, then scroll immediately to the destination
-  if (!StaticPrefs::SmoothScrollEnabled()) {
+  if (!StaticPrefs::general_smoothScroll()) {
     CancelAnimation();
 
     // CallDispatchScroll interprets the start and end points as the start and
     // end of a touch scroll so they need to be reversed.
     ParentLayerPoint startPoint = destination * Metrics().GetZoom();
     ParentLayerPoint endPoint =
         Metrics().GetScrollOffset() * Metrics().GetZoom();
     ParentLayerPoint delta = endPoint - startPoint;
--- a/gfx/layers/apz/src/GenericScrollAnimation.cpp
+++ b/gfx/layers/apz/src/GenericScrollAnimation.cpp
@@ -15,17 +15,17 @@
 
 namespace mozilla {
 namespace layers {
 
 GenericScrollAnimation::GenericScrollAnimation(
     AsyncPanZoomController& aApzc, const nsPoint& aInitialPosition,
     const ScrollAnimationBezierPhysicsSettings& aSettings)
     : mApzc(aApzc), mFinalDestination(aInitialPosition) {
-  if (StaticPrefs::SmoothScrollMSDPhysicsEnabled()) {
+  if (StaticPrefs::general_smoothScroll_msdPhysics_enabled()) {
     mAnimationPhysics = MakeUnique<ScrollAnimationMSDPhysics>(aInitialPosition);
   } else {
     mAnimationPhysics =
         MakeUnique<ScrollAnimationBezierPhysics>(aInitialPosition, aSettings);
   }
 }
 
 void GenericScrollAnimation::UpdateDelta(TimeStamp aTime, const nsPoint& aDelta,
--- a/gfx/layers/apz/src/KeyboardScrollAnimation.cpp
+++ b/gfx/layers/apz/src/KeyboardScrollAnimation.cpp
@@ -13,35 +13,42 @@ namespace layers {
 static ScrollAnimationBezierPhysicsSettings SettingsForType(
     KeyboardScrollAction::KeyboardScrollActionType aType) {
   int32_t minMS = 0;
   int32_t maxMS = 0;
 
   switch (aType) {
     case KeyboardScrollAction::eScrollCharacter:
     case KeyboardScrollAction::eScrollLine: {
-      maxMS = clamped(StaticPrefs::LineSmoothScrollMaxDurationMs(), 0, 10000);
-      minMS = clamped(StaticPrefs::LineSmoothScrollMinDurationMs(), 0, maxMS);
+      maxMS = clamped(StaticPrefs::general_smoothScroll_lines_durationMaxMS(),
+                      0, 10000);
+      minMS = clamped(StaticPrefs::general_smoothScroll_lines_durationMinMS(),
+                      0, maxMS);
       break;
     }
     case KeyboardScrollAction::eScrollPage: {
-      maxMS = clamped(StaticPrefs::PageSmoothScrollMaxDurationMs(), 0, 10000);
-      minMS = clamped(StaticPrefs::PageSmoothScrollMinDurationMs(), 0, maxMS);
+      maxMS = clamped(StaticPrefs::general_smoothScroll_pages_durationMaxMS(),
+                      0, 10000);
+      minMS = clamped(StaticPrefs::general_smoothScroll_pages_durationMinMS(),
+                      0, maxMS);
       break;
     }
     case KeyboardScrollAction::eScrollComplete: {
-      maxMS = clamped(StaticPrefs::OtherSmoothScrollMaxDurationMs(), 0, 10000);
-      minMS = clamped(StaticPrefs::OtherSmoothScrollMinDurationMs(), 0, maxMS);
+      maxMS = clamped(StaticPrefs::general_smoothScroll_other_durationMaxMS(),
+                      0, 10000);
+      minMS = clamped(StaticPrefs::general_smoothScroll_other_durationMinMS(),
+                      0, maxMS);
       break;
     }
   }
 
   // The pref is 100-based int percentage, while mIntervalRatio is 1-based ratio
   double intervalRatio =
-      ((double)StaticPrefs::SmoothScrollDurationToIntervalRatio()) / 100.0;
+      ((double)StaticPrefs::general_smoothScroll_durationToIntervalRatio()) /
+      100.0;
   intervalRatio = std::max(1.0, intervalRatio);
   return ScrollAnimationBezierPhysicsSettings{minMS, maxMS, intervalRatio};
 }
 
 KeyboardScrollAnimation::KeyboardScrollAnimation(
     AsyncPanZoomController& aApzc, const nsPoint& aInitialPosition,
     KeyboardScrollAction::KeyboardScrollActionType aType)
     : GenericScrollAnimation(aApzc, aInitialPosition, SettingsForType(aType)) {}
--- a/gfx/layers/apz/src/WheelScrollAnimation.cpp
+++ b/gfx/layers/apz/src/WheelScrollAnimation.cpp
@@ -16,32 +16,41 @@ namespace layers {
 
 static ScrollAnimationBezierPhysicsSettings SettingsForDeltaType(
     ScrollWheelInput::ScrollDeltaType aDeltaType) {
   int32_t minMS = 0;
   int32_t maxMS = 0;
 
   switch (aDeltaType) {
     case ScrollWheelInput::SCROLLDELTA_PAGE:
-      maxMS = clamped(StaticPrefs::PageSmoothScrollMaxDurationMs(), 0, 10000);
-      minMS = clamped(StaticPrefs::PageSmoothScrollMinDurationMs(), 0, maxMS);
+      maxMS = clamped(StaticPrefs::general_smoothScroll_pages_durationMaxMS(),
+                      0, 10000);
+      minMS = clamped(StaticPrefs::general_smoothScroll_pages_durationMinMS(),
+                      0, maxMS);
       break;
     case ScrollWheelInput::SCROLLDELTA_PIXEL:
-      maxMS = clamped(StaticPrefs::PixelSmoothScrollMaxDurationMs(), 0, 10000);
-      minMS = clamped(StaticPrefs::PixelSmoothScrollMinDurationMs(), 0, maxMS);
+      maxMS = clamped(StaticPrefs::general_smoothScroll_pixels_durationMaxMS(),
+                      0, 10000);
+      minMS = clamped(StaticPrefs::general_smoothScroll_pixels_durationMinMS(),
+                      0, maxMS);
       break;
     case ScrollWheelInput::SCROLLDELTA_LINE:
-      maxMS = clamped(StaticPrefs::WheelSmoothScrollMaxDurationMs(), 0, 10000);
-      minMS = clamped(StaticPrefs::WheelSmoothScrollMinDurationMs(), 0, maxMS);
+      maxMS =
+          clamped(StaticPrefs::general_smoothScroll_mouseWheel_durationMaxMS(),
+                  0, 10000);
+      minMS =
+          clamped(StaticPrefs::general_smoothScroll_mouseWheel_durationMinMS(),
+                  0, maxMS);
       break;
   }
 
   // The pref is 100-based int percentage, while mIntervalRatio is 1-based ratio
   double intervalRatio =
-      ((double)StaticPrefs::SmoothScrollDurationToIntervalRatio()) / 100.0;
+      ((double)StaticPrefs::general_smoothScroll_durationToIntervalRatio()) /
+      100.0;
   intervalRatio = std::max(1.0, intervalRatio);
   return ScrollAnimationBezierPhysicsSettings{minMS, maxMS, intervalRatio};
 }
 
 WheelScrollAnimation::WheelScrollAnimation(
     AsyncPanZoomController& aApzc, const nsPoint& aInitialPosition,
     ScrollWheelInput::ScrollDeltaType aDeltaType)
     : GenericScrollAnimation(aApzc, aInitialPosition,
--- a/layout/generic/ScrollAnimationBezierPhysics.cpp
+++ b/layout/generic/ScrollAnimationBezierPhysics.cpp
@@ -87,32 +87,34 @@ void ScrollAnimationBezierPhysics::Initi
   mPrevEventTime[1] = mPrevEventTime[0] - maxDelta;
   mPrevEventTime[2] = mPrevEventTime[1] - maxDelta;
 }
 
 void ScrollAnimationBezierPhysics::InitTimingFunction(
     SMILKeySpline& aTimingFunction, nscoord aCurrentPos,
     nscoord aCurrentVelocity, nscoord aDestination) {
   if (aDestination == aCurrentPos ||
-      StaticPrefs::SmoothScrollCurrentVelocityWeighting() == 0) {
+      StaticPrefs::general_smoothScroll_currentVelocityWeighting() == 0) {
     aTimingFunction.Init(
-        0, 0, 1 - StaticPrefs::SmoothScrollStopDecelerationWeighting(), 1);
+        0, 0, 1 - StaticPrefs::general_smoothScroll_stopDecelerationWeighting(),
+        1);
     return;
   }
 
   const TimeDuration oneSecond = TimeDuration::FromSeconds(1);
   double slope =
       aCurrentVelocity * (mDuration / oneSecond) / (aDestination - aCurrentPos);
   double normalization = sqrt(1.0 + slope * slope);
-  double dt =
-      1.0 / normalization * StaticPrefs::SmoothScrollCurrentVelocityWeighting();
+  double dt = 1.0 / normalization *
+              StaticPrefs::general_smoothScroll_currentVelocityWeighting();
   double dxy = slope / normalization *
-               StaticPrefs::SmoothScrollCurrentVelocityWeighting();
+               StaticPrefs::general_smoothScroll_currentVelocityWeighting();
   aTimingFunction.Init(
-      dt, dxy, 1 - StaticPrefs::SmoothScrollStopDecelerationWeighting(), 1);
+      dt, dxy,
+      1 - StaticPrefs::general_smoothScroll_stopDecelerationWeighting(), 1);
 }
 
 nsPoint ScrollAnimationBezierPhysics::PositionAt(const TimeStamp& aTime) {
   if (IsFinished(aTime)) {
     return mDestination;
   }
 
   double progressX = mTimingFunctionX.GetSplineValue(ProgressAt(aTime));
--- a/layout/generic/ScrollAnimationMSDPhysics.cpp
+++ b/layout/generic/ScrollAnimationMSDPhysics.cpp
@@ -5,20 +5,24 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "ScrollAnimationMSDPhysics.h"
 
 using namespace mozilla;
 
 ScrollAnimationMSDPhysics::ScrollAnimationMSDPhysics(const nsPoint& aStartPos)
     : mStartPos(aStartPos),
-      mModelX(0, 0, 0,
-              StaticPrefs::SmoothScrollMSDPhysicsRegularSpringConstant(), 1),
-      mModelY(0, 0, 0,
-              StaticPrefs::SmoothScrollMSDPhysicsRegularSpringConstant(), 1),
+      mModelX(
+          0, 0, 0,
+          StaticPrefs::general_smoothScroll_msdPhysics_regularSpringConstant(),
+          1),
+      mModelY(
+          0, 0, 0,
+          StaticPrefs::general_smoothScroll_msdPhysics_regularSpringConstant(),
+          1),
       mIsFirstIteration(true) {}
 
 void ScrollAnimationMSDPhysics::Update(const TimeStamp& aTime,
                                        const nsPoint& aDestination,
                                        const nsSize& aCurrentVelocity) {
   double springConstant = ComputeSpringConstant(aTime);
 
   // mLastSimulatedTime is the most recent time that this animation has been
@@ -51,44 +55,50 @@ void ScrollAnimationMSDPhysics::ApplyCon
   mDestination += shiftDelta;
 }
 
 double ScrollAnimationMSDPhysics::ComputeSpringConstant(
     const TimeStamp& aTime) {
   if (!mPreviousEventTime) {
     mPreviousEventTime = aTime;
     mPreviousDelta = TimeDuration();
-    return StaticPrefs::SmoothScrollMSDPhysicsMotionBeginSpringConstant();
+    return StaticPrefs::
+        general_smoothScroll_msdPhysics_motionBeginSpringConstant();
   }
 
   TimeDuration delta = aTime - mPreviousEventTime;
   TimeDuration previousDelta = mPreviousDelta;
 
   mPreviousEventTime = aTime;
   mPreviousDelta = delta;
 
   double deltaMS = delta.ToMilliseconds();
   if (deltaMS >=
-      StaticPrefs::SmoothScrollMSDPhysicsContinuousMotionMaxDeltaMS()) {
-    return StaticPrefs::SmoothScrollMSDPhysicsMotionBeginSpringConstant();
+      StaticPrefs::
+          general_smoothScroll_msdPhysics_continuousMotionMaxDeltaMS()) {
+    return StaticPrefs::
+        general_smoothScroll_msdPhysics_motionBeginSpringConstant();
   }
 
   if (previousDelta &&
-      deltaMS >= StaticPrefs::SmoothScrollMSDPhysicsSlowdownMinDeltaMS() &&
+      deltaMS >=
+          StaticPrefs::general_smoothScroll_msdPhysics_slowdownMinDeltaMS() &&
       deltaMS >=
           previousDelta.ToMilliseconds() *
-              StaticPrefs::SmoothScrollMSDPhysicsSlowdownMinDeltaRatio()) {
+              StaticPrefs::
+                  general_smoothScroll_msdPhysics_slowdownMinDeltaRatio()) {
     // The rate of events has slowed (the time delta between events has
     // increased) enough that we think that the current scroll motion is coming
     // to a stop. Use a stiffer spring in order to reach the destination more
     // quickly.
-    return StaticPrefs::SmoothScrollMSDPhysicsSlowdownSpringConstant();
+    return StaticPrefs::
+        general_smoothScroll_msdPhysics_slowdownSpringConstant();
   }
 
-  return StaticPrefs::SmoothScrollMSDPhysicsRegularSpringConstant();
+  return StaticPrefs::general_smoothScroll_msdPhysics_regularSpringConstant();
 }
 
 void ScrollAnimationMSDPhysics::SimulateUntil(const TimeStamp& aTime) {
   if (!mLastSimulatedTime || aTime < mLastSimulatedTime) {
     return;
   }
   TimeDuration delta = aTime - mLastSimulatedTime;
   mModelX.Simulate(delta);
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -1986,17 +1986,17 @@ void ScrollFrameHelper::AsyncScroll::Ini
   }
   // Likewise we should never get APZ-triggered scrolls here, and if that
   // changes something is likely broken somewhere.
   MOZ_ASSERT(aOrigin != nsGkAtoms::apz);
 
   // Read preferences only on first iteration or for a different event origin.
   if (!mAnimationPhysics || aOrigin != mOrigin) {
     mOrigin = aOrigin;
-    if (StaticPrefs::SmoothScrollMSDPhysicsEnabled()) {
+    if (StaticPrefs::general_smoothScroll_msdPhysics_enabled()) {
       mAnimationPhysics =
           MakeUnique<ScrollAnimationMSDPhysics>(aInitialPosition);
     } else {
       ScrollAnimationBezierPhysicsSettings settings =
           ComputeBezierAnimationSettingsForOrigin(mOrigin);
       mAnimationPhysics =
           MakeUnique<ScrollAnimationBezierPhysics>(aInitialPosition, settings);
     }
--- a/modules/libpref/init/StaticPrefList.h
+++ b/modules/libpref/init/StaticPrefList.h
@@ -2753,172 +2753,172 @@ VARCACHE_PREF(
 
 //---------------------------------------------------------------------------
 // Prefs starting with "general."
 //---------------------------------------------------------------------------
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll",
-  SmoothScrollEnabled,
+   general_smoothScroll,
   RelaxedAtomicBool, true
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.currentVelocityWeighting",
-  SmoothScrollCurrentVelocityWeighting,
+   general_smoothScroll_currentVelocityWeighting,
   AtomicFloat, 0.25
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.durationToIntervalRatio",
-  SmoothScrollDurationToIntervalRatio,
+   general_smoothScroll_durationToIntervalRatio,
   RelaxedAtomicInt32, 200
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.lines.durationMaxMS",
-  LineSmoothScrollMaxDurationMs,
+   general_smoothScroll_lines_durationMaxMS,
   RelaxedAtomicInt32, 150
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.lines.durationMinMS",
-  LineSmoothScrollMinDurationMs,
+   general_smoothScroll_lines_durationMinMS,
   RelaxedAtomicInt32, 150
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.mouseWheel",
-  WheelSmoothScrollEnabled,
+   general_smoothScroll_mouseWheel,
   RelaxedAtomicBool, true
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.mouseWheel.durationMaxMS",
-  WheelSmoothScrollMaxDurationMs,
+   general_smoothScroll_mouseWheel_durationMaxMS,
   RelaxedAtomicInt32, 400
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.mouseWheel.durationMinMS",
-  WheelSmoothScrollMinDurationMs,
+   general_smoothScroll_mouseWheel_durationMinMS,
   RelaxedAtomicInt32, 200
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.other.durationMaxMS",
-  OtherSmoothScrollMaxDurationMs,
+   general_smoothScroll_other_durationMaxMS,
   RelaxedAtomicInt32, 150
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.other.durationMinMS",
-  OtherSmoothScrollMinDurationMs,
+   general_smoothScroll_other_durationMinMS,
   RelaxedAtomicInt32, 150
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.pages",
-  PageSmoothScrollEnabled,
+   general_smoothScroll_pages,
   RelaxedAtomicBool, true
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.pages.durationMaxMS",
-  PageSmoothScrollMaxDurationMs,
+   general_smoothScroll_pages_durationMaxMS,
   RelaxedAtomicInt32, 150
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.pages.durationMinMS",
-  PageSmoothScrollMinDurationMs,
+   general_smoothScroll_pages_durationMinMS,
   RelaxedAtomicInt32, 150
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.pixels.durationMaxMS",
-  PixelSmoothScrollMaxDurationMs,
+   general_smoothScroll_pixels_durationMaxMS,
   RelaxedAtomicInt32, 150
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.pixels.durationMinMS",
-  PixelSmoothScrollMinDurationMs,
+   general_smoothScroll_pixels_durationMinMS,
   RelaxedAtomicInt32, 150
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.stopDecelerationWeighting",
-  SmoothScrollStopDecelerationWeighting,
+  general_smoothScroll_stopDecelerationWeighting,
   AtomicFloat, 0.4f
 )
 
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.msdPhysics.enabled",
-  SmoothScrollMSDPhysicsEnabled,
+   general_smoothScroll_msdPhysics_enabled,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.msdPhysics.continuousMotionMaxDeltaMS",
-  SmoothScrollMSDPhysicsContinuousMotionMaxDeltaMS,
+   general_smoothScroll_msdPhysics_continuousMotionMaxDeltaMS,
   RelaxedAtomicInt32, 120
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.msdPhysics.motionBeginSpringConstant",
-  SmoothScrollMSDPhysicsMotionBeginSpringConstant,
+   general_smoothScroll_msdPhysics_motionBeginSpringConstant,
   RelaxedAtomicInt32, 1250
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.msdPhysics.slowdownMinDeltaMS",
-  SmoothScrollMSDPhysicsSlowdownMinDeltaMS,
+   general_smoothScroll_msdPhysics_slowdownMinDeltaMS,
   RelaxedAtomicInt32, 12
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.msdPhysics.slowdownMinDeltaRatio",
-  SmoothScrollMSDPhysicsSlowdownMinDeltaRatio,
+   general_smoothScroll_msdPhysics_slowdownMinDeltaRatio,
   AtomicFloat, 1.3f
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.msdPhysics.slowdownSpringConstant",
-  SmoothScrollMSDPhysicsSlowdownSpringConstant,
+   general_smoothScroll_msdPhysics_slowdownSpringConstant,
   RelaxedAtomicInt32, 2000
 )
 
 VARCACHE_PREF(
   Live,
   "general.smoothScroll.msdPhysics.regularSpringConstant",
-  SmoothScrollMSDPhysicsRegularSpringConstant,
+   general_smoothScroll_msdPhysics_regularSpringConstant,
   RelaxedAtomicInt32, 1000
 )
 
 //---------------------------------------------------------------------------
 // Prefs starting with "gfx."
 //---------------------------------------------------------------------------
 
 VARCACHE_PREF(
--- a/widget/cocoa/nsChildView.mm
+++ b/widget/cocoa/nsChildView.mm
@@ -4387,17 +4387,17 @@ static gfx::IntPoint GetIntegerDeltaForE
         // pass up the necessary wheel delta adjustment.
         WheelDeltaAdjustmentStrategy::eNone);
     wheelEvent.mLineOrPageDeltaX = lineOrPageDelta.x;
     wheelEvent.mLineOrPageDeltaY = lineOrPageDelta.y;
     wheelEvent.mIsMomentum = nsCocoaUtils::IsMomentumScrollEvent(theEvent);
     geckoChildDeathGrip->DispatchAPZWheelInputEvent(wheelEvent, false);
   } else {
     ScrollWheelInput::ScrollMode scrollMode = ScrollWheelInput::SCROLLMODE_INSTANT;
-    if (StaticPrefs::SmoothScrollEnabled() && StaticPrefs::WheelSmoothScrollEnabled()) {
+    if (StaticPrefs::general_smoothScroll() && StaticPrefs::general_smoothScroll_mouseWheel()) {
       scrollMode = ScrollWheelInput::SCROLLMODE_SMOOTH;
     }
     ScrollWheelInput wheelEvent(eventIntervalTime, eventTimeStamp, modifiers, scrollMode,
                                 ScrollWheelInput::SCROLLDELTA_LINE, position, lineOrPageDelta.x,
                                 lineOrPageDelta.y, false,
                                 // This parameter is used for wheel delta
                                 // adjustment, such as auto-dir scrolling,
                                 // but we do't need to do anything special here