diff --git a/dom/canvas/WebGL2ContextSync.cpp b/dom/canvas/WebGL2ContextSync.cpp
index 8c265166c566..3019b066372d 100644
--- a/dom/canvas/WebGL2ContextSync.cpp
+++ b/dom/canvas/WebGL2ContextSync.cpp
@@ -67,7 +67,7 @@ GLenum WebGL2Context::ClientWaitSync(const WebGLSync& sync, GLbitfield flags,
   }
 
   const bool canBeAvailable =
-      (sync.mCanBeAvailable || StaticPrefs::WebGLImmediateQueries());
+      (sync.mCanBeAvailable || StaticPrefs::webgl_allow_immediate_queries());
   if (!canBeAvailable) {
     if (timeout) {
       GenerateWarning(
@@ -118,7 +118,7 @@ void WebGL2Context::GetSyncParameter(JSContext*, const WebGLSync& sync,
   ////
 
   const bool canBeAvailable =
-      (sync.mCanBeAvailable || StaticPrefs::WebGLImmediateQueries());
+      (sync.mCanBeAvailable || StaticPrefs::webgl_allow_immediate_queries());
   if (!canBeAvailable && pname == LOCAL_GL_SYNC_STATUS) {
     retval.set(JS::Int32Value(LOCAL_GL_UNSIGNALED));
     return;
diff --git a/dom/canvas/WebGLContext.cpp b/dom/canvas/WebGLContext.cpp
index d092f422d435..4229753bc92a 100644
--- a/dom/canvas/WebGLContext.cpp
+++ b/dom/canvas/WebGLContext.cpp
@@ -98,8 +98,8 @@ using namespace mozilla::layers;
 
 WebGLContextOptions::WebGLContextOptions() {
   // Set default alpha state based on preference.
-  alpha = !StaticPrefs::WebGLDefaultNoAlpha();
-  antialias = StaticPrefs::WebGLDefaultAntialias();
+  alpha = !StaticPrefs::webgl_default_no_alpha();
+  antialias = StaticPrefs::webgl_default_antialias();
 }
 
 bool WebGLContextOptions::operator==(const WebGLContextOptions& r) const {
@@ -118,18 +118,18 @@ bool WebGLContextOptions::operator==(const WebGLContextOptions& r) const {
 WebGLContext::WebGLContext()
     : gl(mGL_OnlyClearInDestroyResourcesAndContext)  // const reference
       ,
-      mMaxPerfWarnings(StaticPrefs::WebGLMaxPerfWarnings()),
+      mMaxPerfWarnings(StaticPrefs::webgl_perf_max_warnings()),
       mNumPerfWarnings(0),
       mMaxAcceptableFBStatusInvals(
-          StaticPrefs::WebGLMaxAcceptableFBStatusInvals()),
+          StaticPrefs::webgl_perf_max_acceptable_fb_status_invals()),
       mDataAllocGLCallCount(0),
       mEmptyTFO(0),
       mContextLossHandler(this),
       mNeedsFakeNoAlpha(false),
       mNeedsFakeNoDepth(false),
       mNeedsFakeNoStencil(false),
-      mAllowFBInvalidation(StaticPrefs::WebGLFBInvalidation()),
-      mMsaaSamples((uint8_t)StaticPrefs::WebGLMsaaSamples()) {
+      mAllowFBInvalidation(StaticPrefs::webgl_allow_fb_invalidation()),
+      mMsaaSamples((uint8_t)StaticPrefs::webgl_msaa_samples()) {
   mGeneration = 0;
   mInvalidated = false;
   mCapturedFrameInvalidated = false;
@@ -165,7 +165,7 @@ WebGLContext::WebGLContext()
   mAlreadyWarnedAboutFakeVertexAttrib0 = false;
   mAlreadyWarnedAboutViewportLargerThanDest = false;
 
-  mMaxWarnings = StaticPrefs::WebGLMaxWarningsPerContext();
+  mMaxWarnings = StaticPrefs::webgl_max_warnings_per_context();
   if (mMaxWarnings < -1) {
     GenerateWarning(
         "webgl.max-warnings-per-context size is too large (seems like a "
@@ -367,7 +367,7 @@ WebGLContext::SetContextOptions(JSContext* cx, JS::Handle<JS::Value> options,
     newOpts.antialias = false;
   }
 
-  if (newOpts.antialias && !StaticPrefs::WebGLForceMSAA()) {
+  if (newOpts.antialias && !StaticPrefs::webgl_msaa_force()) {
     const nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
 
     nsCString blocklistId;
@@ -479,7 +479,7 @@ bool WebGLContext::CreateAndInitGL(
 
   if (IsWebGL2()) {
     flags |= gl::CreateContextFlags::PREFER_ES3;
-  } else if (!StaticPrefs::WebGL1AllowCoreProfile()) {
+  } else if (!StaticPrefs::webgl_1_allow_core_profiles()) {
     flags |= gl::CreateContextFlags::REQUIRE_COMPAT_PROFILE;
   }
 
@@ -504,7 +504,7 @@ bool WebGLContext::CreateAndInitGL(
         // ads/trackers)
       default:
         highPower = true;
-        if (StaticPrefs::WebGLDefaultLowPower()) {
+        if (StaticPrefs::webgl_default_low_power()) {
           highPower = false;
         } else if (mCanvasElement && !mCanvasElement->GetParentNode()) {
           GenerateWarning(
@@ -559,12 +559,12 @@ bool WebGLContext::CreateAndInitGL(
   tryNativeGL = false;
   tryANGLE = true;
 
-  if (StaticPrefs::WebGLDisableWGL()) {
+  if (StaticPrefs::webgl_disable_wgl()) {
     tryNativeGL = false;
   }
 
-  if (StaticPrefs::WebGLDisableANGLE() || PR_GetEnv("MOZ_WEBGL_FORCE_OPENGL") ||
-      useEGL) {
+  if (StaticPrefs::webgl_disable_angle() ||
+      PR_GetEnv("MOZ_WEBGL_FORCE_OPENGL") || useEGL) {
     tryNativeGL = true;
     tryANGLE = false;
   }
@@ -819,7 +819,7 @@ WebGLContext::SetDimensions(int32_t signedWidth, int32_t signedHeight) {
   // pick up the old generation.
   ++mGeneration;
 
-  bool disabled = StaticPrefs::WebGLDisabled();
+  bool disabled = StaticPrefs::webgl_disabled();
 
   // TODO: When we have software webgl support we should use that instead.
   disabled |= gfxPlatform::InSafeMode();
@@ -835,7 +835,7 @@ WebGLContext::SetDimensions(int32_t signedWidth, int32_t signedHeight) {
     return NS_ERROR_FAILURE;
   }
 
-  if (StaticPrefs::WebGLDisableFailIfMajorPerformanceCaveat()) {
+  if (StaticPrefs::webgl_disable_fail_if_major_performance_caveat()) {
     mOptions.failIfMajorPerformanceCaveat = false;
   }
 
@@ -852,7 +852,7 @@ WebGLContext::SetDimensions(int32_t signedWidth, int32_t signedHeight) {
   }
 
   // Alright, now let's start trying.
-  bool forceEnabled = StaticPrefs::WebGLForceEnabled();
+  bool forceEnabled = StaticPrefs::webgl_force_enabled();
   ScopedGfxFeatureReporter reporter("WebGL", forceEnabled);
 
   MOZ_ASSERT(!gl);
@@ -984,9 +984,9 @@ WebGLContext::SetDimensions(int32_t signedWidth, int32_t signedHeight) {
 }
 
 void WebGLContext::LoseOldestWebGLContextIfLimitExceeded() {
-  const auto maxWebGLContexts = StaticPrefs::WebGLMaxContexts();
+  const auto maxWebGLContexts = StaticPrefs::webgl_max_contexts();
   auto maxWebGLContextsPerPrincipal =
-      StaticPrefs::WebGLMaxContextsPerPrincipal();
+      StaticPrefs::webgl_max_contexts_per_principal();
 
   // maxWebGLContextsPerPrincipal must be less than maxWebGLContexts
   MOZ_ASSERT(maxWebGLContextsPerPrincipal <= maxWebGLContexts);
@@ -1348,7 +1348,7 @@ ScopedPrepForResourceClear::~ScopedPrepForResourceClear() {
 // -
 
 void WebGLContext::OnEndOfFrame() const {
-  if (StaticPrefs::WebGLSpewFrameAllocs()) {
+  if (StaticPrefs::webgl_perf_spew_frame_allocs()) {
     GeneratePerfWarning("[webgl.perf.spew-frame-allocs] %" PRIu64
                         " data allocations this frame.",
                         mDataAllocGLCallCount);
diff --git a/dom/canvas/WebGLContextExtensions.cpp b/dom/canvas/WebGLContextExtensions.cpp
index a1dceba9c8c5..4d4481e9ae3e 100644
--- a/dom/canvas/WebGLContextExtensions.cpp
+++ b/dom/canvas/WebGLContextExtensions.cpp
@@ -82,7 +82,7 @@ bool WebGLContext::IsExtensionSupported(dom::CallerType callerType,
     allowPrivilegedExts = true;
   }
 
-  if (StaticPrefs::WebGLPrivilegedExtensionsEnabled()) {
+  if (StaticPrefs::webgl_enable_privileged_extensions()) {
     allowPrivilegedExts = true;
   }
 
diff --git a/dom/canvas/WebGLContextValidate.cpp b/dom/canvas/WebGLContextValidate.cpp
index 9c3e2df2f1ea..057d3a881b9e 100644
--- a/dom/canvas/WebGLContextValidate.cpp
+++ b/dom/canvas/WebGLContextValidate.cpp
@@ -288,10 +288,11 @@ bool WebGLContext::InitAndValidateGL(FailureReason* const out_failReason) {
     return false;
   }
 
-  mDisableExtensions = StaticPrefs::WebGLDisableExtensions();
+  mDisableExtensions = StaticPrefs::webgl_disable_extensions();
   mLoseContextOnMemoryPressure =
-      StaticPrefs::WebGLLoseContextOnMemoryPressure();
-  mCanLoseContextInForeground = StaticPrefs::WebGLCanLoseContextInForeground();
+      StaticPrefs::webgl_lose_context_on_memory_pressure();
+  mCanLoseContextInForeground =
+      StaticPrefs::webgl_can_lose_context_in_foreground();
 
   // These are the default values, see 6.2 State tables in the
   // OpenGL ES 2.0.25 spec.
@@ -476,7 +477,7 @@ bool WebGLContext::InitAndValidateGL(FailureReason* const out_failReason) {
 
   ////////////////
 
-  if (StaticPrefs::WebGLMinCapabilityMode()) {
+  if (StaticPrefs::webgl_min_capability_mode()) {
     bool ok = true;
 
     ok &= RestrictCap(&mGLMaxVertexTextureImageUnits,
@@ -653,7 +654,7 @@ bool WebGLContext::InitAndValidateGL(FailureReason* const out_failReason) {
 
   mNeedsIndexValidation =
       !gl->IsSupported(gl::GLFeature::robust_buffer_access_behavior);
-  switch (StaticPrefs::WebGLForceIndexValidation()) {
+  switch (StaticPrefs::webgl_force_index_validation()) {
     case -1:
       mNeedsIndexValidation = false;
       break;
@@ -661,7 +662,7 @@ bool WebGLContext::InitAndValidateGL(FailureReason* const out_failReason) {
       mNeedsIndexValidation = true;
       break;
     default:
-      MOZ_ASSERT(StaticPrefs::WebGLForceIndexValidation() == 0);
+      MOZ_ASSERT(StaticPrefs::webgl_force_index_validation() == 0);
       break;
   }
 
diff --git a/dom/canvas/WebGLExtensions.cpp b/dom/canvas/WebGLExtensions.cpp
index 7c7176cf95c9..579bdc247c2d 100644
--- a/dom/canvas/WebGLExtensions.cpp
+++ b/dom/canvas/WebGLExtensions.cpp
@@ -36,7 +36,7 @@ WebGLExtensionExplicitPresent::WebGLExtensionExplicitPresent(WebGLContext* const
 }
 
 bool WebGLExtensionExplicitPresent::IsSupported(const WebGLContext* const webgl) {
-  return StaticPrefs::WebGLDraftExtensionsEnabled();
+  return StaticPrefs::webgl_enable_draft_extensions();
 }
 
 void WebGLExtensionExplicitPresent::Present() const {
@@ -81,7 +81,9 @@ WebGLExtensionFBORenderMipmap::~WebGLExtensionFBORenderMipmap() = default;
 bool WebGLExtensionFBORenderMipmap::IsSupported(
     const WebGLContext* const webgl) {
   if (webgl->IsWebGL2()) return false;
-  if (!StaticPrefs::WebGLDraftExtensionsEnabled()) return false;
+  if (!StaticPrefs::webgl_enable_draft_extensions()) {
+    return false;
+  }
 
   const auto& gl = webgl->gl;
   if (!gl->IsGLES()) return true;
@@ -102,7 +104,9 @@ WebGLExtensionMultiview::~WebGLExtensionMultiview() = default;
 
 bool WebGLExtensionMultiview::IsSupported(const WebGLContext* const webgl) {
   if (!webgl->IsWebGL2()) return false;
-  if (!StaticPrefs::WebGLDraftExtensionsEnabled()) return false;
+  if (!StaticPrefs::webgl_enable_draft_extensions()) {
+    return false;
+  }
 
   const auto& gl = webgl->gl;
   return gl->IsSupported(gl::GLFeature::multiview);
diff --git a/dom/canvas/WebGLQuery.cpp b/dom/canvas/WebGLQuery.cpp
index 17e5e6d8da0c..e484ca1d7d3e 100644
--- a/dom/canvas/WebGLQuery.cpp
+++ b/dom/canvas/WebGLQuery.cpp
@@ -116,7 +116,7 @@ void WebGLQuery::GetQueryParameter(GLenum pname,
 
   // We must usually wait for an event loop before the query can be available.
   const bool canBeAvailable =
-      (mCanBeAvailable || StaticPrefs::WebGLImmediateQueries());
+      (mCanBeAvailable || StaticPrefs::webgl_allow_immediate_queries());
   if (!canBeAvailable) {
     if (pname == LOCAL_GL_QUERY_RESULT_AVAILABLE) {
       retval.set(JS::BooleanValue(false));
diff --git a/dom/canvas/WebGLShaderValidator.cpp b/dom/canvas/WebGLShaderValidator.cpp
index 2c8888d11b10..8efbb593652d 100644
--- a/dom/canvas/WebGLShaderValidator.cpp
+++ b/dom/canvas/WebGLShaderValidator.cpp
@@ -67,7 +67,7 @@ static ShCompileOptions ChooseValidatorCompileOptions(
     }
   }
 
-  if (StaticPrefs::WebGLAllANGLEOptions()) {
+  if (StaticPrefs::webgl_all_angle_options()) {
     options = -1;
 
     options ^= SH_INTERMEDIATE_TREE;
diff --git a/dom/canvas/WebGLTextureUpload.cpp b/dom/canvas/WebGLTextureUpload.cpp
index 378e4ad2a860..f6ab719f88e8 100644
--- a/dom/canvas/WebGLTextureUpload.cpp
+++ b/dom/canvas/WebGLTextureUpload.cpp
@@ -328,7 +328,7 @@ UniquePtr<webgl::TexUnpackBlob> WebGLContext::FromDomElem(
   uint32_t elemWidth = 0;
   uint32_t elemHeight = 0;
   layers::Image* layersImage = nullptr;
-  if (!StaticPrefs::WebGLDisableDOMBlitUploads() && sfer.mLayersImage) {
+  if (!StaticPrefs::webgl_disable_DOM_blit_uploads() && sfer.mLayersImage) {
     layersImage = sfer.mLayersImage;
     elemWidth = layersImage->GetSize().width;
     elemHeight = layersImage->GetSize().height;
diff --git a/gfx/gl/GLLibraryEGL.cpp b/gfx/gl/GLLibraryEGL.cpp
index 485e948d2ccd..d53ef804cbf2 100644
--- a/gfx/gl/GLLibraryEGL.cpp
+++ b/gfx/gl/GLLibraryEGL.cpp
@@ -289,14 +289,14 @@ static EGLDisplay GetAndInitDisplayForAccelANGLE(
 
   FeatureState& d3d11ANGLE = gfxConfig::GetFeature(Feature::D3D11_HW_ANGLE);
 
-  if (!StaticPrefs::WebGLANGLETryD3D11())
+  if (!StaticPrefs::webgl_angle_try_d3d11()) {
     d3d11ANGLE.UserDisable("User disabled D3D11 ANGLE by pref",
                            NS_LITERAL_CSTRING("FAILURE_ID_ANGLE_PREF"));
-
-  if (StaticPrefs::WebGLANGLEForceD3D11())
+  }
+  if (StaticPrefs::webgl_angle_force_d3d11()) {
     d3d11ANGLE.UserForceEnable(
         "User force-enabled D3D11 ANGLE on disabled hardware");
-
+  }
   gAngleErrorReporter.SetFailureId(out_failureId);
 
   auto guardShutdown = mozilla::MakeScopeExit([&] {
@@ -741,7 +741,7 @@ EGLDisplay GLLibraryEGL::CreateDisplay(bool forceAccel,
     bool shouldTryWARP = !forceAccel;  // Only if ANGLE not supported or fails
 
     // If WARP preferred, will override ANGLE support
-    if (StaticPrefs::WebGLANGLEForceWARP()) {
+    if (StaticPrefs::webgl_angle_force_warp()) {
       shouldTryWARP = true;
       shouldTryAccel = false;
       if (accelAngleFailureId.IsEmpty()) {
diff --git a/gfx/gl/GLScreenBuffer.cpp b/gfx/gl/GLScreenBuffer.cpp
index 8a7fb0322bfe..e148d5a3a889 100644
--- a/gfx/gl/GLScreenBuffer.cpp
+++ b/gfx/gl/GLScreenBuffer.cpp
@@ -66,11 +66,11 @@ UniquePtr<SurfaceFactory> GLScreenBuffer::CreateFactory(
   const bool useANGLE = compositorConnection->GetCompositorUseANGLE();
 
   const bool useGl =
-      !StaticPrefs::WebGLForceLayersReadback() &&
+      !StaticPrefs::webgl_force_layers_readback() &&
       (backend == layers::LayersBackend::LAYERS_OPENGL ||
        (backend == layers::LayersBackend::LAYERS_WR && !useANGLE));
   const bool useD3D =
-      !StaticPrefs::WebGLForceLayersReadback() &&
+      !StaticPrefs::webgl_force_layers_readback() &&
       (backend == layers::LayersBackend::LAYERS_D3D11 ||
        (backend == layers::LayersBackend::LAYERS_WR && useANGLE));
 
@@ -85,7 +85,7 @@ UniquePtr<SurfaceFactory> GLScreenBuffer::CreateFactory(
     factory = MakeUnique<SurfaceFactory_GLTexture>(mGLContext, caps, ipcChannel,
                                                    mFlags);
 #elif defined(MOZ_WIDGET_ANDROID)
-    if (XRE_IsParentProcess() && !StaticPrefs::WebGLSurfaceTextureEnabled()) {
+    if (XRE_IsParentProcess() && !StaticPrefs::webgl_enable_surface_texture()) {
       factory = SurfaceFactory_EGLImage::Create(gl, caps, ipcChannel, flags);
     } else {
       factory =
@@ -114,7 +114,7 @@ UniquePtr<SurfaceFactory> GLScreenBuffer::CreateFactory(
           SurfaceFactory_ANGLEShareHandle::Create(gl, caps, ipcChannel, flags);
     }
 
-    if (!factory && StaticPrefs::WebGLDXGLEnabled()) {
+    if (!factory && StaticPrefs::webgl_dxgl_enabled()) {
       factory =
           SurfaceFactory_D3D11Interop::Create(gl, caps, ipcChannel, flags);
     }
diff --git a/gfx/gl/SharedSurfaceD3D11Interop.cpp b/gfx/gl/SharedSurfaceD3D11Interop.cpp
index 28fc37be6ebe..431f058ff755 100644
--- a/gfx/gl/SharedSurfaceD3D11Interop.cpp
+++ b/gfx/gl/SharedSurfaceD3D11Interop.cpp
@@ -414,7 +414,7 @@ SharedSurface_D3D11Interop::SharedSurface_D3D11Interop(
       mLockHandle(lockHandle),
       mTexD3D(texD3D),
       mDXGIHandle(dxgiHandle),
-      mNeedsFinish(StaticPrefs::WebGLDXGLNeedsFinish()),
+      mNeedsFinish(StaticPrefs::webgl_dxgl_needs_finish()),
       mLockedForGL(false) {
   MOZ_ASSERT(bool(mProdTex) == bool(mInteropFB));
 }
diff --git a/gfx/src/DriverCrashGuard.cpp b/gfx/src/DriverCrashGuard.cpp
index 1d9b4e3f3a66..b38fed07b7bf 100644
--- a/gfx/src/DriverCrashGuard.cpp
+++ b/gfx/src/DriverCrashGuard.cpp
@@ -509,11 +509,11 @@ bool GLContextCrashGuard::UpdateEnvironment() {
 
 #if defined(XP_WIN)
   changed |= CheckAndUpdateBoolPref("gfx.driver-init.webgl-angle-force-d3d11",
-                                    StaticPrefs::WebGLANGLEForceD3D11());
+                                    StaticPrefs::webgl_angle_force_d3d11());
   changed |= CheckAndUpdateBoolPref("gfx.driver-init.webgl-angle-try-d3d11",
-                                    StaticPrefs::WebGLANGLETryD3D11());
+                                    StaticPrefs::webgl_angle_try_d3d11());
   changed |= CheckAndUpdateBoolPref("gfx.driver-init.webgl-angle-force-warp",
-                                    StaticPrefs::WebGLANGLEForceWARP());
+                                    StaticPrefs::webgl_angle_force_warp());
   changed |= CheckAndUpdateBoolPref(
       "gfx.driver-init.webgl-angle",
       FeatureEnabled(nsIGfxInfo::FEATURE_WEBGL_ANGLE, false));
diff --git a/gfx/thebes/gfxPlatform.cpp b/gfx/thebes/gfxPlatform.cpp
index 7a95daf44498..e3e0384063bd 100644
--- a/gfx/thebes/gfxPlatform.cpp
+++ b/gfx/thebes/gfxPlatform.cpp
@@ -922,11 +922,12 @@ void gfxPlatform::Init() {
         StaticPrefs::layers_d3d11_force_warp());
     // WebGL prefs
     forcedPrefs.AppendPrintf(
-        "-W%d%d%d%d%d%d%d%d", StaticPrefs::WebGLANGLEForceD3D11(),
-        StaticPrefs::WebGLANGLEForceWARP(), StaticPrefs::WebGLDisabled(),
-        StaticPrefs::WebGLDisableANGLE(), StaticPrefs::WebGLDXGLEnabled(),
-        StaticPrefs::WebGLForceEnabled(),
-        StaticPrefs::WebGLForceLayersReadback(), StaticPrefs::WebGLForceMSAA());
+        "-W%d%d%d%d%d%d%d%d", StaticPrefs::webgl_angle_force_d3d11(),
+        StaticPrefs::webgl_angle_force_warp(), StaticPrefs::webgl_disabled(),
+        StaticPrefs::webgl_disable_angle(), StaticPrefs::webgl_dxgl_enabled(),
+        StaticPrefs::webgl_force_enabled(),
+        StaticPrefs::webgl_force_layers_readback(),
+        StaticPrefs::webgl_msaa_force());
     // Prefs that don't fit into any of the other sections
     forcedPrefs.AppendPrintf("-T%d%d%d) ",
                              StaticPrefs::gfx_android_rgb16_force(),
diff --git a/modules/libpref/init/StaticPrefList.h b/modules/libpref/init/StaticPrefList.h
index e8db7b8e0435..098b3cdc8113 100644
--- a/modules/libpref/init/StaticPrefList.h
+++ b/modules/libpref/init/StaticPrefList.h
@@ -7244,7 +7244,7 @@ VARCACHE_PREF(
 VARCACHE_PREF(
   Live,
   "webgl.1.allow-core-profiles",
-  WebGL1AllowCoreProfile,
+   webgl_1_allow_core_profiles,
   RelaxedAtomicBool, false
 )
 
@@ -7252,35 +7252,35 @@ VARCACHE_PREF(
 VARCACHE_PREF(
   Live,
   "webgl.all-angle-options",
-  WebGLAllANGLEOptions,
+   webgl_all_angle_options,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.angle.force-d3d11",
-  WebGLANGLEForceD3D11,
+   webgl_angle_force_d3d11,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.angle.try-d3d11",
-  WebGLANGLETryD3D11,
+   webgl_angle_try_d3d11,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.angle.force-warp",
-  WebGLANGLEForceWARP,
+   webgl_angle_force_warp,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.can-lose-context-in-foreground",
-  WebGLCanLoseContextInForeground,
+   webgl_can_lose_context_in_foreground,
   RelaxedAtomicBool, true
 )
 
@@ -7292,7 +7292,7 @@ VARCACHE_PREF(
 VARCACHE_PREF(
   Live,
   "webgl.default-antialias",
-  WebGLDefaultAntialias,
+   webgl_default_antialias,
   RelaxedAtomicBool, PREF_VALUE
 )
 #undef PREF_VALUE
@@ -7300,49 +7300,49 @@ VARCACHE_PREF(
 VARCACHE_PREF(
   Live,
   "webgl.default-low-power",
-  WebGLDefaultLowPower,
+   webgl_default_low_power,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.default-no-alpha",
-  WebGLDefaultNoAlpha,
+   webgl_default_no_alpha,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.disable-angle",
-  WebGLDisableANGLE,
+   webgl_disable_angle,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.disable-wgl",
-  WebGLDisableWGL,
+   webgl_disable_wgl,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.disable-extensions",
-  WebGLDisableExtensions,
+   webgl_disable_extensions,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.dxgl.enabled",
-  WebGLDXGLEnabled,
+   webgl_dxgl_enabled,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.dxgl.needs-finish",
-  WebGLDXGLNeedsFinish,
+   webgl_dxgl_needs_finish,
   RelaxedAtomicBool, false
 )
 
@@ -7350,42 +7350,42 @@ VARCACHE_PREF(
 VARCACHE_PREF(
   Live,
   "webgl.disable-fail-if-major-performance-caveat",
-  WebGLDisableFailIfMajorPerformanceCaveat,
+   webgl_disable_fail_if_major_performance_caveat,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.disable-DOM-blit-uploads",
-  WebGLDisableDOMBlitUploads,
+   webgl_disable_DOM_blit_uploads,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.disabled",
-  WebGLDisabled,
+   webgl_disabled,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.enable-draft-extensions",
-  WebGLDraftExtensionsEnabled,
+   webgl_enable_draft_extensions,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.enable-privileged-extensions",
-  WebGLPrivilegedExtensionsEnabled,
+   webgl_enable_privileged_extensions,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.enable-surface-texture",
-  WebGLSurfaceTextureEnabled,
+   webgl_enable_surface_texture,
   RelaxedAtomicBool, false
 )
 
@@ -7399,91 +7399,86 @@ VARCACHE_PREF(
 VARCACHE_PREF(
   Live,
   "webgl.force-enabled",
-  WebGLForceEnabled,
+   webgl_force_enabled,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.force-layers-readback",
-  WebGLForceLayersReadback,
+   webgl_force_layers_readback,
   bool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.force-index-validation",
-  WebGLForceIndexValidation,
+   webgl_force_index_validation,
   RelaxedAtomicInt32, 0
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.lose-context-on-memory-pressure",
-  WebGLLoseContextOnMemoryPressure,
+   webgl_lose_context_on_memory_pressure,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.max-contexts",
-  WebGLMaxContexts,
+   webgl_max_contexts,
   RelaxedAtomicUint32, 32
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.max-contexts-per-principal",
-  WebGLMaxContextsPerPrincipal,
+   webgl_max_contexts_per_principal,
   RelaxedAtomicUint32, 16
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.max-warnings-per-context",
-  WebGLMaxWarningsPerContext,
+   webgl_max_warnings_per_context,
   RelaxedAtomicUint32, 32
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.min_capability_mode",
-  WebGLMinCapabilityMode,
+   webgl_min_capability_mode,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.msaa-force",
-  WebGLForceMSAA,
+   webgl_msaa_force,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.msaa-samples",
-  WebGLMsaaSamples,
+   webgl_msaa_samples,
   RelaxedAtomicUint32, 4
 )
 
-VARCACHE_PREF(
-  Live,
-  "webgl.prefer-16bpp",
-  WebGLPrefer16bpp,
-  RelaxedAtomicBool, false
-)
+PREF("webgl.prefer-16bpp", bool, false)
 
 VARCACHE_PREF(
   Live,
   "webgl.allow-immediate-queries",
-  WebGLImmediateQueries,
+   webgl_allow_immediate_queries,
   RelaxedAtomicBool, false
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.allow-fb-invalidation",
-  WebGLFBInvalidation,
+   webgl_allow_fb_invalidation,
   RelaxedAtomicBool, false
 )
 
@@ -7491,21 +7486,21 @@ VARCACHE_PREF(
 VARCACHE_PREF(
   Live,
   "webgl.perf.max-warnings",
-  WebGLMaxPerfWarnings,
+   webgl_perf_max_warnings,
   RelaxedAtomicInt32, 0
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.perf.max-acceptable-fb-status-invals",
-  WebGLMaxAcceptableFBStatusInvals,
+   webgl_perf_max_acceptable_fb_status_invals,
   RelaxedAtomicInt32, 0
 )
 
 VARCACHE_PREF(
   Live,
   "webgl.perf.spew-frame-allocs",
-  WebGLSpewFrameAllocs,
+   webgl_perf_spew_frame_allocs,
   RelaxedAtomicBool, true
 )