--- a/modules/libpref/Preferences.cpp
+++ b/modules/libpref/Preferences.cpp
@@ -230,28 +230,28 @@ enum
 {
   kPrefSetDefault = 1,
   kPrefForceSet = 2,
   kPrefSticky = 4,
 };
 
 static ArenaAllocator<8192, 1> gPrefNameArena;
 
-class PrefHashEntry : public PLDHashEntryHdr
+class Pref : public PLDHashEntryHdr
 {
 public:
-  PrefHashEntry(const char* aName, PrefType aType)
+  Pref(const char* aName, PrefType aType)
   {
     mName = ArenaStrdup(aName, gPrefNameArena);
     SetType(aType);
     // We don't set the other fields because PLDHashTable always zeroes new
     // entries.
   }
 
-  ~PrefHashEntry()
+  ~Pref()
   {
     // There's no need to free mName because it's allocated in memory owned by
     // gPrefNameArena.
 
     if (IsTypeString()) {
       free(const_cast<char*>(mDefaultValue.mStringVal));
       free(const_cast<char*>(mUserValue.mStringVal));
     }
@@ -276,35 +276,35 @@ public:
 
   bool HasDefaultValue() const { return mHasDefaultValue; }
   bool HasUserValue() const { return mHasUserValue; }
 
   // Other operations.
 
   static bool MatchEntry(const PLDHashEntryHdr* aEntry, const void* aKey)
   {
-    auto pref = static_cast<const PrefHashEntry*>(aEntry);
+    auto pref = static_cast<const Pref*>(aEntry);
     auto key = static_cast<const char*>(aKey);
 
     if (pref->mName == aKey) {
       return true;
     }
 
     if (!pref->mName || !aKey) {
       return false;
     }
 
     return strcmp(pref->mName, key) == 0;
   }
 
   static void ClearEntry(PLDHashTable* aTable, PLDHashEntryHdr* aEntry)
   {
-    auto pref = static_cast<PrefHashEntry*>(aEntry);
-    pref->~PrefHashEntry();
-    memset(pref, 0, sizeof(PrefHashEntry)); // zero just to be extra safe
+    auto pref = static_cast<Pref*>(aEntry);
+    pref->~Pref();
+    memset(pref, 0, sizeof(Pref)); // zero just to be extra safe
   }
 
   nsresult GetBoolValue(PrefValueKind aKind, bool* aResult)
   {
     if (!IsTypeBool()) {
       return NS_ERROR_UNEXPECTED;
     }
 
@@ -637,39 +637,39 @@ static CallbackNode* gLastPriorityNode =
 static bool gIsAnyPrefLocked = false;
 
 // These are only used during the call to NotifyCallbacks().
 static bool gCallbacksInProgress = false;
 static bool gShouldCleanupDeadNodes = false;
 
 static PLDHashTableOps pref_HashTableOps = {
   PLDHashTable::HashStringKey,
-  PrefHashEntry::MatchEntry,
+  Pref::MatchEntry,
   PLDHashTable::MoveEntryStub,
-  PrefHashEntry::ClearEntry,
+  Pref::ClearEntry,
   nullptr,
 };
 
 //---------------------------------------------------------------------------
 
-static PrefHashEntry*
+static Pref*
 pref_HashTableLookup(const char* aPrefName);
 
 static void
 NotifyCallbacks(const char* aPrefName);
 
 #define PREF_HASHTABLE_INITIAL_LENGTH 1024
 
 static PrefSaveData
 pref_savePrefs()
 {
   PrefSaveData savedPrefs(gHashTable->EntryCount());
 
   for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
-    auto pref = static_cast<PrefHashEntry*>(iter.Get());
+    auto pref = static_cast<Pref*>(iter.Get());
 
     nsAutoCString prefValueStr;
     if (!pref->UserValueToStringForSaving(prefValueStr)) {
       continue;
     }
 
     nsAutoCString prefNameStr;
     StrEscape(pref->Name(), prefNameStr);
@@ -727,17 +727,17 @@ public:
 #define AUTO_INSTALLING_CALLBACK() AutoInstallingCallback installingRAII
 
 #else // DEBUG
 
 #define AUTO_INSTALLING_CALLBACK()
 
 #endif // DEBUG
 
-static PrefHashEntry*
+static Pref*
 pref_HashTableLookup(const char* aKey)
 {
   MOZ_ASSERT(NS_IsMainThread() || mozilla::ServoStyleSet::IsInServoTraversal());
   MOZ_ASSERT((XRE_IsParentProcess() || gPhase != START),
              "pref access before commandline prefs set");
 
   // If you're hitting this assertion, you've added a pref access to start up.
   // Consider moving it later or add it to the whitelist in ContentPrefs.cpp
@@ -750,39 +750,39 @@ pref_HashTableLookup(const char* aKey)
 #ifdef DEBUG
   if (!XRE_IsParentProcess() && gPhase <= END_INIT_PREFS &&
       !gInstallingCallback && !InInitArray(aKey)) {
     MOZ_CRASH_UNSAFE_PRINTF(
       "accessing non-init pref %s before the rest of the prefs are sent", aKey);
   }
 #endif
 
-  return static_cast<PrefHashEntry*>(gHashTable->Search(aKey));
+  return static_cast<Pref*>(gHashTable->Search(aKey));
 }
 
 static nsresult
 pref_SetPref(const char* aPrefName,
              PrefValue aValue,
              PrefType aType,
              uint32_t aFlags)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!gHashTable) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
-  auto pref = static_cast<PrefHashEntry*>(gHashTable->Add(aPrefName, fallible));
+  auto pref = static_cast<Pref*>(gHashTable->Add(aPrefName, fallible));
   if (!pref) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   if (!pref->Name()) {
     // New (zeroed) entry. Initialize it.
-    new (pref) PrefHashEntry(aPrefName, aType);
+    new (pref) Pref(aPrefName, aType);
   }
 
   bool valueChanged = false, handleDirty = false;
   nsresult rv =
     pref->SetValue(aType, aValue, aFlags, &valueChanged, &handleDirty);
   if (NS_FAILED(rv)) {
     NS_WARNING(
       nsPrintfCString(
@@ -1824,17 +1824,17 @@ nsPrefBranch::GetRoot(nsACString& aRoot)
 }
 
 NS_IMETHODIMP
 nsPrefBranch::GetPrefType(const char* aPrefName, int32_t* aRetVal)
 {
   NS_ENSURE_ARG(aPrefName);
 
   const PrefName& prefName = GetPrefName(aPrefName);
-  PrefHashEntry* pref;
+  Pref* pref;
   if (gHashTable && (pref = pref_HashTableLookup(prefName.get()))) {
     switch (pref->Type()) {
       case PrefType::String:
         *aRetVal = PREF_STRING;
         break;
 
       case PrefType::Int:
         *aRetVal = PREF_INT;
@@ -2369,17 +2369,17 @@ nsPrefBranch::DeleteBranch(const char* a
       !StringEndsWith(branchName, NS_LITERAL_CSTRING("."))) {
     branchName += '.';
   }
 
   const nsACString& branchNameNoDot =
     Substring(branchName, 0, branchName.Length() - 1);
 
   for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
-    auto pref = static_cast<PrefHashEntry*>(iter.Get());
+    auto pref = static_cast<Pref*>(iter.Get());
 
     // The first disjunct matches branches: e.g. a branch name "foo.bar."
     // matches a name "foo.bar.baz" (but it won't match "foo.barrel.baz").
     // The second disjunct matches leaf nodes: e.g. a branch name "foo.bar."
     // matches a name "foo.bar" (by ignoring the trailing '.').
     nsDependentCString name(pref->Name());
     if (StringBeginsWith(name, branchName) || name.Equals(branchNameNoDot)) {
       iter.Remove();
@@ -2408,17 +2408,17 @@ nsPrefBranch::GetChildList(const char* a
   *aCount = 0;
 
   // This will contain a list of all the pref name strings. Allocated on the
   // stack for speed.
 
   const PrefName& parent = GetPrefName(aStartingAt);
   size_t parentLen = parent.Length();
   for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
-    auto pref = static_cast<PrefHashEntry*>(iter.Get());
+    auto pref = static_cast<Pref*>(iter.Get());
     if (strncmp(pref->Name(), parent.get(), parentLen) == 0) {
       prefArray.AppendElement(pref->Name());
     }
   }
 
   // Now that we've built up the list, run the callback on all the matching
   // elements.
   numPrefs = prefArray.Length();
@@ -3061,17 +3061,17 @@ PreferenceServiceReporter::CollectReport
   MallocSizeOf mallocSizeOf = PreferenceServiceMallocSizeOf;
   PrefsSizes sizes;
 
   Preferences::AddSizeOfIncludingThis(mallocSizeOf, sizes);
 
   if (gHashTable) {
     sizes.mHashTable += gHashTable->ShallowSizeOfIncludingThis(mallocSizeOf);
     for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
-      auto pref = static_cast<PrefHashEntry*>(iter.Get());
+      auto pref = static_cast<Pref*>(iter.Get());
       sizes.mStringValues += pref->SizeOfExcludingThis(mallocSizeOf);
     }
   }
 
   if (gCacheData) {
     sizes.mCacheData += gCacheData->ShallowSizeOfIncludingThis(mallocSizeOf);
     for (uint32_t i = 0, count = gCacheData->Length(); i < count; ++i) {
       sizes.mCacheData += mallocSizeOf((*gCacheData)[i]);
@@ -3248,17 +3248,17 @@ Preferences::GetInstanceForService()
     gCacheDataDesc = "shutting down in GetInstanceForService()";
     return nullptr;
   }
 
   sPreferences = new Preferences();
 
   MOZ_ASSERT(!gHashTable);
   gHashTable = new PLDHashTable(
-    &pref_HashTableOps, sizeof(PrefHashEntry), PREF_HASHTABLE_INITIAL_LENGTH);
+    &pref_HashTableOps, sizeof(Pref), PREF_HASHTABLE_INITIAL_LENGTH);
 
   Result<Ok, const char*> res = InitInitialObjects();
   if (res.isErr()) {
     sPreferences = nullptr;
     gCacheDataDesc = res.unwrapErr();
     return nullptr;
   }
 
@@ -3513,17 +3513,17 @@ NS_IMETHODIMP
 Preferences::ResetUserPrefs()
 {
   ENSURE_PARENT_PROCESS("Preferences::ResetUserPrefs", "all prefs");
   NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
   MOZ_ASSERT(NS_IsMainThread());
 
   Vector<const char*> prefNames;
   for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
-    auto pref = static_cast<PrefHashEntry*>(iter.Get());
+    auto pref = static_cast<Pref*>(iter.Get());
 
     if (pref->HasUserValue()) {
       if (!prefNames.append(pref->Name())) {
         return NS_ERROR_OUT_OF_MEMORY;
       }
 
       pref->ClearUserValue();
       if (!pref->HasDefaultValue()) {
@@ -3633,28 +3633,28 @@ Preferences::SetPreference(const dom::Pr
 
   // NB: we should never try to clear a default value, that doesn't
   // make sense
 }
 
 void
 Preferences::GetPreference(dom::Pref* aDomPref)
 {
-  PrefHashEntry* pref = pref_HashTableLookup(aDomPref->name().get());
+  Pref* pref = pref_HashTableLookup(aDomPref->name().get());
   if (pref && pref->HasAdvisablySizedValues()) {
     pref->ToDomPref(aDomPref);
   }
 }
 
 void
 Preferences::GetPreferences(InfallibleTArray<dom::Pref>* aDomPrefs)
 {
   aDomPrefs->SetCapacity(gHashTable->EntryCount());
   for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
-    auto pref = static_cast<PrefHashEntry*>(iter.Get());
+    auto pref = static_cast<Pref*>(iter.Get());
 
     if (pref->HasAdvisablySizedValues()) {
       dom::Pref* setting = aDomPrefs->AppendElement();
       pref->ToDomPref(setting);
     }
   }
 }
 
@@ -4300,29 +4300,29 @@ Preferences::InitInitialObjects()
 //----------------------------------------------------------------------------
 
 /* static */ nsresult
 Preferences::GetBool(const char* aPrefName, bool* aResult, PrefValueKind aKind)
 {
   NS_PRECONDITION(aResult, "aResult must not be NULL");
   NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
 
-  PrefHashEntry* pref = pref_HashTableLookup(aPrefName);
+  Pref* pref = pref_HashTableLookup(aPrefName);
   return pref ? pref->GetBoolValue(aKind, aResult) : NS_ERROR_UNEXPECTED;
 }
 
 /* static */ nsresult
 Preferences::GetInt(const char* aPrefName,
                     int32_t* aResult,
                     PrefValueKind aKind)
 {
   NS_PRECONDITION(aResult, "aResult must not be NULL");
   NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
 
-  PrefHashEntry* pref = pref_HashTableLookup(aPrefName);
+  Pref* pref = pref_HashTableLookup(aPrefName);
   return pref ? pref->GetIntValue(aKind, aResult) : NS_ERROR_UNEXPECTED;
 }
 
 /* static */ nsresult
 Preferences::GetFloat(const char* aPrefName,
                       float* aResult,
                       PrefValueKind aKind)
 {
@@ -4340,17 +4340,17 @@ Preferences::GetFloat(const char* aPrefN
 Preferences::GetCString(const char* aPrefName,
                         nsACString& aResult,
                         PrefValueKind aKind)
 {
   NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
 
   aResult.SetIsVoid(true);
 
-  PrefHashEntry* pref = pref_HashTableLookup(aPrefName);
+  Pref* pref = pref_HashTableLookup(aPrefName);
   return pref ? pref->GetCStringValue(aKind, aResult) : NS_ERROR_UNEXPECTED;
 }
 
 /* static */ nsresult
 Preferences::GetString(const char* aPrefName,
                        nsAString& aResult,
                        PrefValueKind aKind)
 {
@@ -4488,17 +4488,17 @@ Preferences::SetComplex(const char* aPre
   return GetRootBranch(aKind)->SetComplexValue(aPrefName, aType, aValue);
 }
 
 /* static */ nsresult
 Preferences::LockInAnyProcess(const char* aPrefName)
 {
   NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
 
-  PrefHashEntry* pref = pref_HashTableLookup(aPrefName);
+  Pref* pref = pref_HashTableLookup(aPrefName);
   if (!pref) {
     return NS_ERROR_UNEXPECTED;
   }
 
   if (!pref->IsLocked()) {
     pref->SetIsLocked(true);
     gIsAnyPrefLocked = true;
     NotifyCallbacks(aPrefName);
@@ -4515,17 +4515,17 @@ Preferences::Lock(const char* aPrefName)
 }
 
 /* static */ nsresult
 Preferences::Unlock(const char* aPrefName)
 {
   ENSURE_PARENT_PROCESS("Unlock", aPrefName);
   NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
 
-  PrefHashEntry* pref = pref_HashTableLookup(aPrefName);
+  Pref* pref = pref_HashTableLookup(aPrefName);
   if (!pref) {
     return NS_ERROR_UNEXPECTED;
   }
 
   if (pref->IsLocked()) {
     pref->SetIsLocked(false);
     NotifyCallbacks(aPrefName);
   }
@@ -4534,31 +4534,31 @@ Preferences::Unlock(const char* aPrefNam
 }
 
 /* static */ bool
 Preferences::IsLocked(const char* aPrefName)
 {
   NS_ENSURE_TRUE(InitStaticMembers(), false);
 
   if (gIsAnyPrefLocked) {
-    PrefHashEntry* pref = pref_HashTableLookup(aPrefName);
+    Pref* pref = pref_HashTableLookup(aPrefName);
     if (pref && pref->IsLocked()) {
       return true;
     }
   }
 
   return false;
 }
 
 /* static */ nsresult
 Preferences::ClearUserInAnyProcess(const char* aPrefName)
 {
   NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
 
-  PrefHashEntry* pref = pref_HashTableLookup(aPrefName);
+  Pref* pref = pref_HashTableLookup(aPrefName);
   if (pref && pref->HasUserValue()) {
     pref->ClearUserValue();
 
     if (!pref->HasDefaultValue()) {
       gHashTable->RemoveEntry(pref);
     }
 
     NotifyCallbacks(aPrefName);
@@ -4574,17 +4574,17 @@ Preferences::ClearUser(const char* aPref
   return ClearUserInAnyProcess(aPrefName);
 }
 
 /* static */ bool
 Preferences::HasUserValue(const char* aPrefName)
 {
   NS_ENSURE_TRUE(InitStaticMembers(), false);
 
-  PrefHashEntry* pref = pref_HashTableLookup(aPrefName);
+  Pref* pref = pref_HashTableLookup(aPrefName);
   return pref && pref->HasUserValue();
 }
 
 /* static */ int32_t
 Preferences::GetType(const char* aPrefName, PrefValueKind aKind)
 {
   NS_ENSURE_TRUE(InitStaticMembers(), nsIPrefBranch::PREF_INVALID);
   int32_t result;