--- a/modules/libpref/Preferences.cpp
+++ b/modules/libpref/Preferences.cpp
@@ -246,42 +246,42 @@ private:
   };
   uint16_t mValue;
 };
 
 struct PrefHashEntry : PLDHashEntryHdr
 {
   PrefTypeFlags mPrefFlags; // this field first to minimize 64-bit struct size
   const char* mKey;
-  PrefValue mDefaultPref;
-  PrefValue mUserPref;
+  PrefValue mDefaultValue;
+  PrefValue mUserValue;
 
   size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf)
   {
     // Note: mKey is allocated in gPrefNameArena, measured elsewhere.
     size_t n = 0;
     if (mPrefFlags.IsTypeString()) {
       if (mPrefFlags.HasDefaultValue()) {
-        n += aMallocSizeOf(mDefaultPref.mStringVal);
+        n += aMallocSizeOf(mDefaultValue.mStringVal);
       }
       if (mPrefFlags.HasUserValue()) {
-        n += aMallocSizeOf(mUserPref.mStringVal);
+        n += aMallocSizeOf(mUserValue.mStringVal);
       }
     }
     return n;
   }
 };
 
 static void
 ClearPrefEntry(PLDHashTable* aTable, PLDHashEntryHdr* aEntry)
 {
   auto pref = static_cast<PrefHashEntry*>(aEntry);
   if (pref->mPrefFlags.IsTypeString()) {
-    free(const_cast<char*>(pref->mDefaultPref.mStringVal));
-    free(const_cast<char*>(pref->mUserPref.mStringVal));
+    free(const_cast<char*>(pref->mDefaultValue.mStringVal));
+    free(const_cast<char*>(pref->mUserValue.mStringVal));
   }
 
   // Don't need to free this because it's allocated in memory owned by
   // gPrefNameArena.
   pref->mKey = nullptr;
   memset(aEntry, 0, aTable->EntrySize());
 }
 
@@ -416,42 +416,42 @@ static PrefSaveData
 pref_savePrefs()
 {
   PrefSaveData savedPrefs(gHashTable->EntryCount());
 
   for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
     auto pref = static_cast<PrefHashEntry*>(iter.Get());
 
     // where we're getting our pref from
-    PrefValue* sourcePref;
+    PrefValue* sourceValue;
 
     if (pref->mPrefFlags.HasUserValue() &&
-        (pref_ValueChanged(pref->mDefaultPref,
-                           pref->mUserPref,
+        (pref_ValueChanged(pref->mDefaultValue,
+                           pref->mUserValue,
                            pref->mPrefFlags.GetPrefType()) ||
          !pref->mPrefFlags.HasDefaultValue() ||
          pref->mPrefFlags.IsSticky())) {
-      sourcePref = &pref->mUserPref;
+      sourceValue = &pref->mUserValue;
     } else {
       // do not save default prefs that haven't changed
       continue;
     }
 
     nsAutoCString prefName;
     StrEscape(pref->mKey, prefName);
 
     nsAutoCString prefValue;
     if (pref->mPrefFlags.IsTypeString()) {
-      StrEscape(sourcePref->mStringVal, prefValue);
+      StrEscape(sourceValue->mStringVal, prefValue);
 
     } else if (pref->mPrefFlags.IsTypeInt()) {
-      prefValue.AppendInt(sourcePref->mIntVal);
+      prefValue.AppendInt(sourceValue->mIntVal);
 
     } else if (pref->mPrefFlags.IsTypeBool()) {
-      prefValue = sourcePref->mBoolVal ? "true" : "false";
+      prefValue = sourceValue->mBoolVal ? "true" : "false";
     }
 
     nsPrintfCString str("user_pref(%s, %s);", prefName.get(), prefValue.get());
     savedPrefs.AppendElement(str);
   }
 
   return savedPrefs;
 }
@@ -460,45 +460,45 @@ static bool
 pref_EntryHasAdvisablySizedValues(PrefHashEntry* aHashEntry)
 {
   if (aHashEntry->mPrefFlags.GetPrefType() != PrefType::String) {
     return true;
   }
 
   const char* stringVal;
   if (aHashEntry->mPrefFlags.HasDefaultValue()) {
-    stringVal = aHashEntry->mDefaultPref.mStringVal;
+    stringVal = aHashEntry->mDefaultValue.mStringVal;
     if (strlen(stringVal) > MAX_ADVISABLE_PREF_LENGTH) {
       return false;
     }
   }
 
   if (aHashEntry->mPrefFlags.HasUserValue()) {
-    stringVal = aHashEntry->mUserPref.mStringVal;
+    stringVal = aHashEntry->mUserValue.mStringVal;
     if (strlen(stringVal) > MAX_ADVISABLE_PREF_LENGTH) {
       return false;
     }
   }
 
   return true;
 }
 
 static void
 GetPrefValueFromEntry(PrefHashEntry* aHashEntry,
                       dom::PrefSetting* aPref,
                       PrefValueKind aKind)
 {
   PrefValue* value;
   dom::PrefValue* settingValue;
   if (aKind == PrefValueKind::User) {
-    value = &aHashEntry->mUserPref;
+    value = &aHashEntry->mUserValue;
     aPref->userValue() = dom::PrefValue();
     settingValue = &aPref->userValue().get_PrefValue();
   } else {
-    value = &aHashEntry->mDefaultPref;
+    value = &aHashEntry->mDefaultValue;
     aPref->defaultValue() = dom::PrefValue();
     settingValue = &aPref->defaultValue().get_PrefValue();
   }
 
   switch (aHashEntry->mPrefFlags.GetPrefType()) {
     case PrefType::String:
       *settingValue = nsDependentCString(value->mStringVal);
       return;
@@ -768,18 +768,18 @@ pref_SetPref(const char* aKey,
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   // New entry, need to initialize.
   if (!pref->mKey) {
     // Initialize the pref entry.
     pref->mPrefFlags.Reset().SetPrefType(aType);
     pref->mKey = ArenaStrdup(aKey, gPrefNameArena);
-    memset(&pref->mDefaultPref, 0, sizeof(pref->mDefaultPref));
-    memset(&pref->mUserPref, 0, sizeof(pref->mUserPref));
+    memset(&pref->mDefaultValue, 0, sizeof(pref->mDefaultValue));
+    memset(&pref->mUserValue, 0, sizeof(pref->mUserValue));
 
   } else if (pref->mPrefFlags.HasDefaultValue() &&
              !pref->mPrefFlags.IsPrefType(aType)) {
     NS_WARNING(
       nsPrintfCString(
         "Ignoring attempt to overwrite value of default pref %s (type %s) with "
         "the wrong type (%s)!",
         aKey,
@@ -789,20 +789,20 @@ pref_SetPref(const char* aKey,
 
     return NS_ERROR_UNEXPECTED;
   }
 
   bool valueChanged = false;
   if (aFlags & kPrefSetDefault) {
     if (!pref->mPrefFlags.IsLocked()) {
       // ?? change of semantics?
-      if (pref_ValueChanged(pref->mDefaultPref, aValue, aType) ||
+      if (pref_ValueChanged(pref->mDefaultValue, aValue, aType) ||
           !pref->mPrefFlags.HasDefaultValue()) {
         pref_SetValue(
-          &pref->mDefaultPref, pref->mPrefFlags.GetPrefType(), aValue, aType);
+          &pref->mDefaultValue, pref->mPrefFlags.GetPrefType(), aValue, aType);
         pref->mPrefFlags.SetPrefType(aType);
         pref->mPrefFlags.SetHasDefaultValue(true);
         if (aFlags & kPrefSticky) {
           pref->mPrefFlags.SetIsSticky(true);
         }
         if (!pref->mPrefFlags.HasUserValue()) {
           valueChanged = true;
         }
@@ -811,31 +811,31 @@ pref_SetPref(const char* aKey,
       // Should we clear the user value?
     }
   } else {
     // If new value is same as the default value and it's not a "sticky" pref,
     // then un-set the user value. Otherwise, set the user value only if it has
     // changed.
     if ((pref->mPrefFlags.HasDefaultValue()) &&
         !(pref->mPrefFlags.IsSticky()) &&
-        !pref_ValueChanged(pref->mDefaultPref, aValue, aType) &&
+        !pref_ValueChanged(pref->mDefaultValue, aValue, aType) &&
         !(aFlags & kPrefForceSet)) {
       if (pref->mPrefFlags.HasUserValue()) {
         // XXX should we free a user-set string value if there is one?
         pref->mPrefFlags.SetHasUserValue(false);
         if (!pref->mPrefFlags.IsLocked()) {
           Preferences::HandleDirty();
           valueChanged = true;
         }
       }
     } else if (!pref->mPrefFlags.HasUserValue() ||
                !pref->mPrefFlags.IsPrefType(aType) ||
-               pref_ValueChanged(pref->mUserPref, aValue, aType)) {
+               pref_ValueChanged(pref->mUserValue, aValue, aType)) {
       pref_SetValue(
-        &pref->mUserPref, pref->mPrefFlags.GetPrefType(), aValue, aType);
+        &pref->mUserValue, pref->mPrefFlags.GetPrefType(), aValue, aType);
       pref->mPrefFlags.SetPrefType(aType);
       pref->mPrefFlags.SetHasUserValue(true);
       if (!pref->mPrefFlags.IsLocked()) {
         Preferences::HandleDirty();
         valueChanged = true;
       }
     }
   }
@@ -4510,19 +4510,19 @@ Preferences::GetBool(const char* aPrefNa
 
   if (aKind == PrefValueKind::Default || pref->mPrefFlags.IsLocked() ||
       !pref->mPrefFlags.HasUserValue()) {
 
     // Do we have a default?
     if (!pref->mPrefFlags.HasDefaultValue()) {
       return NS_ERROR_UNEXPECTED;
     }
-    *aResult = pref->mDefaultPref.mBoolVal;
+    *aResult = pref->mDefaultValue.mBoolVal;
   } else {
-    *aResult = pref->mUserPref.mBoolVal;
+    *aResult = pref->mUserValue.mBoolVal;
   }
 
   return NS_OK;
 }
 
 /* static */ nsresult
 Preferences::GetInt(const char* aPrefName,
                     int32_t* aResult,
@@ -4538,19 +4538,19 @@ Preferences::GetInt(const char* aPrefNam
 
   if (aKind == PrefValueKind::Default || pref->mPrefFlags.IsLocked() ||
       !pref->mPrefFlags.HasUserValue()) {
 
     // Do we have a default?
     if (!pref->mPrefFlags.HasDefaultValue()) {
       return NS_ERROR_UNEXPECTED;
     }
-    *aResult = pref->mDefaultPref.mIntVal;
+    *aResult = pref->mDefaultValue.mIntVal;
   } else {
-    *aResult = pref->mUserPref.mIntVal;
+    *aResult = pref->mUserValue.mIntVal;
   }
 
   return NS_OK;
 }
 
 /* static */ nsresult
 Preferences::GetFloat(const char* aPrefName,
                       float* aResult,
@@ -4583,19 +4583,19 @@ Preferences::GetCString(const char* aPre
   const char* stringVal = nullptr;
   if (aKind == PrefValueKind::Default || pref->mPrefFlags.IsLocked() ||
       !pref->mPrefFlags.HasUserValue()) {
 
     // Do we have a default?
     if (!pref->mPrefFlags.HasDefaultValue()) {
       return NS_ERROR_UNEXPECTED;
     }
-    stringVal = pref->mDefaultPref.mStringVal;
+    stringVal = pref->mDefaultValue.mStringVal;
   } else {
-    stringVal = pref->mUserPref.mStringVal;
+    stringVal = pref->mUserValue.mStringVal;
   }
 
   if (!stringVal) {
     return NS_ERROR_UNEXPECTED;
   }
 
   aResult = stringVal;
   return NS_OK;