--- a/modules/libpref/Preferences.cpp
+++ b/modules/libpref/Preferences.cpp
@@ -283,28 +283,28 @@ ClearPrefEntry(PLDHashTable* aTable, PLD
   // gPrefNameArena.
   pref->mKey = nullptr;
   memset(aEntry, 0, aTable->EntrySize());
 }
 
 static bool
 MatchPrefEntry(const PLDHashEntryHdr* aEntry, const void* aKey)
 {
-  auto prefEntry = static_cast<const PrefHashEntry*>(aEntry);
-
-  if (prefEntry->mKey == aKey) {
+  auto pref = static_cast<const PrefHashEntry*>(aEntry);
+
+  if (pref->mKey == aKey) {
     return true;
   }
 
-  if (!prefEntry->mKey || !aKey) {
+  if (!pref->mKey || !aKey) {
     return false;
   }
 
   auto otherKey = static_cast<const char*>(aKey);
-  return (strcmp(prefEntry->mKey, otherKey) == 0);
+  return (strcmp(pref->mKey, otherKey) == 0);
 }
 
 struct CallbackNode
 {
   const char* mDomain;
 
   // If someone attempts to remove the node from the callback list while
   // pref_DoCallback is running, |func| is set to nullptr. Such nodes will
@@ -452,93 +452,93 @@ pref_savePrefs()
     nsPrintfCString str("user_pref(%s, %s);", prefName.get(), prefValue.get());
     savedPrefs.AppendElement(str);
   }
 
   return savedPrefs;
 }
 
 static bool
-pref_EntryHasAdvisablySizedValues(PrefHashEntry* aHashEntry)
+pref_EntryHasAdvisablySizedValues(PrefHashEntry* aPref)
 {
-  if (aHashEntry->mPrefFlags.GetPrefType() != PrefType::String) {
+  if (aPref->mPrefFlags.GetPrefType() != PrefType::String) {
     return true;
   }
 
   const char* stringVal;
-  if (aHashEntry->mPrefFlags.HasDefaultValue()) {
-    stringVal = aHashEntry->mDefaultValue.mStringVal;
+  if (aPref->mPrefFlags.HasDefaultValue()) {
+    stringVal = aPref->mDefaultValue.mStringVal;
     if (strlen(stringVal) > MAX_ADVISABLE_PREF_LENGTH) {
       return false;
     }
   }
 
-  if (aHashEntry->mPrefFlags.HasUserValue()) {
-    stringVal = aHashEntry->mUserValue.mStringVal;
+  if (aPref->mPrefFlags.HasUserValue()) {
+    stringVal = aPref->mUserValue.mStringVal;
     if (strlen(stringVal) > MAX_ADVISABLE_PREF_LENGTH) {
       return false;
     }
   }
 
   return true;
 }
 
 static void
-GetPrefValueFromEntry(PrefHashEntry* aHashEntry,
-                      dom::PrefSetting* aPref,
+GetPrefValueFromEntry(PrefHashEntry* aPref,
+                      dom::PrefSetting* aSetting,
                       PrefValueKind aKind)
 {
   PrefValue* value;
   dom::PrefValue* settingValue;
   if (aKind == PrefValueKind::User) {
-    value = &aHashEntry->mUserValue;
-    aPref->userValue() = dom::PrefValue();
-    settingValue = &aPref->userValue().get_PrefValue();
+    value = &aPref->mUserValue;
+    aSetting->userValue() = dom::PrefValue();
+    settingValue = &aSetting->userValue().get_PrefValue();
   } else {
-    value = &aHashEntry->mDefaultValue;
-    aPref->defaultValue() = dom::PrefValue();
-    settingValue = &aPref->defaultValue().get_PrefValue();
-  }
-
-  switch (aHashEntry->mPrefFlags.GetPrefType()) {
+    value = &aPref->mDefaultValue;
+    aSetting->defaultValue() = dom::PrefValue();
+    settingValue = &aSetting->defaultValue().get_PrefValue();
+  }
+
+  switch (aPref->mPrefFlags.GetPrefType()) {
     case PrefType::String:
       *settingValue = nsDependentCString(value->mStringVal);
       return;
     case PrefType::Int:
       *settingValue = value->mIntVal;
       return;
     case PrefType::Bool:
       *settingValue = !!value->mBoolVal;
       return;
     default:
       MOZ_CRASH();
   }
 }
 
 static void
-pref_GetPrefFromEntry(PrefHashEntry* aHashEntry, dom::PrefSetting* aPref)
+pref_GetPrefFromEntry(PrefHashEntry* aPref, dom::PrefSetting* aSetting)
 {
-  aPref->name() = aHashEntry->mKey;
-
-  if (aHashEntry->mPrefFlags.HasDefaultValue()) {
-    GetPrefValueFromEntry(aHashEntry, aPref, PrefValueKind::Default);
+  aSetting->name() = aPref->mKey;
+
+  if (aPref->mPrefFlags.HasDefaultValue()) {
+    GetPrefValueFromEntry(aPref, aSetting, PrefValueKind::Default);
   } else {
-    aPref->defaultValue() = null_t();
-  }
-
-  if (aHashEntry->mPrefFlags.HasUserValue()) {
-    GetPrefValueFromEntry(aHashEntry, aPref, PrefValueKind::User);
+    aSetting->defaultValue() = null_t();
+  }
+
+  if (aPref->mPrefFlags.HasUserValue()) {
+    GetPrefValueFromEntry(aPref, aSetting, PrefValueKind::User);
   } else {
-    aPref->userValue() = null_t();
-  }
-
-  MOZ_ASSERT(aPref->defaultValue().type() == dom::MaybePrefValue::Tnull_t ||
-             aPref->userValue().type() == dom::MaybePrefValue::Tnull_t ||
-             (aPref->defaultValue().get_PrefValue().type() ==
-              aPref->userValue().get_PrefValue().type()));
+    aSetting->userValue() = null_t();
+  }
+
+  MOZ_ASSERT(aSetting->defaultValue().type() == dom::MaybePrefValue::Tnull_t ||
+             aSetting->userValue().type() == dom::MaybePrefValue::Tnull_t ||
+             (aSetting->defaultValue().get_PrefValue().type() ==
+              aSetting->userValue().get_PrefValue().type()));
 }
 
 static bool
 PREF_HasUserPref(const char* aPrefName)
 {
   if (!gHashTable) {
     return false;
   }
@@ -2002,22 +2002,22 @@ nsPrefBranch::GetRoot(nsACString& aRoot)
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsPrefBranch::GetPrefType(const char* aPrefName, int32_t* aRetVal)
 {
   NS_ENSURE_ARG(aPrefName);
 
-  const PrefName& pref = GetPrefName(aPrefName);
+  const PrefName& prefName = GetPrefName(aPrefName);
   PrefType type = PrefType::Invalid;
   if (gHashTable) {
-    PrefHashEntry* entry = pref_HashTableLookup(pref.get());
-    if (entry) {
-      type = entry->mPrefFlags.GetPrefType();
+    PrefHashEntry* pref = pref_HashTableLookup(prefName.get());
+    if (pref) {
+      type = pref->mPrefFlags.GetPrefType();
     }
   }
 
   switch (type) {
     case PrefType::String:
       *aRetVal = PREF_STRING;
       break;
 
@@ -2570,23 +2570,23 @@ 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 entry = static_cast<PrefHashEntry*>(iter.Get());
+    auto pref = static_cast<PrefHashEntry*>(iter.Get());
 
     // The first disjunct matches branches: e.g. a branch name "foo.bar."
     // matches an mKey "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 an mKey "foo.bar" (by ignoring the trailing '.').
-    nsDependentCString key(entry->mKey);
+    nsDependentCString key(pref->mKey);
     if (StringBeginsWith(key, branchName) || key.Equals(branchNameNoDot)) {
       iter.Remove();
     }
   }
 
   Preferences::HandleDirty();
   return NS_OK;
 }
@@ -2609,19 +2609,19 @@ 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 entry = static_cast<PrefHashEntry*>(iter.Get());
-    if (strncmp(entry->mKey, parent.get(), parentLen) == 0) {
-      prefArray.AppendElement(entry->mKey);
+    auto pref = static_cast<PrefHashEntry*>(iter.Get());
+    if (strncmp(pref->mKey, parent.get(), parentLen) == 0) {
+      prefArray.AppendElement(pref->mKey);
     }
   }
 
   // Now that we've built up the list, run the callback on all the matching
   // elements.
   numPrefs = prefArray.Length();
 
   if (numPrefs) {
@@ -3272,18 +3272,18 @@ 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 entry = static_cast<PrefHashEntry*>(iter.Get());
-      sizes.mStringValues += entry->SizeOfExcludingThis(mallocSizeOf);
+      auto pref = static_cast<PrefHashEntry*>(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]);
     }
@@ -3441,17 +3441,17 @@ public:
   NS_IMETHOD Run() override
   {
     return RegisterStrongMemoryReporter(new PreferenceServiceReporter());
   }
 };
 
 } // namespace
 
-static InfallibleTArray<Preferences::PrefSetting>* gInitPrefs;
+static InfallibleTArray<Preferences::PrefSetting>* gInitSettings;
 
 /* static */ already_AddRefed<Preferences>
 Preferences::GetInstanceForService()
 {
   if (sPreferences) {
     return do_AddRef(sPreferences);
   }
 
@@ -3469,22 +3469,22 @@ Preferences::GetInstanceForService()
   Result<Ok, const char*> res = InitInitialObjects();
   if (res.isErr()) {
     sPreferences = nullptr;
     gCacheDataDesc = res.unwrapErr();
     return nullptr;
   }
 
   if (!XRE_IsParentProcess()) {
-    MOZ_ASSERT(gInitPrefs);
-    for (unsigned int i = 0; i < gInitPrefs->Length(); i++) {
-      Preferences::SetPreference(gInitPrefs->ElementAt(i));
+    MOZ_ASSERT(gInitSettings);
+    for (unsigned int i = 0; i < gInitSettings->Length(); i++) {
+      Preferences::SetPreference(gInitSettings->ElementAt(i));
     }
-    delete gInitPrefs;
-    gInitPrefs = nullptr;
+    delete gInitSettings;
+    gInitSettings = nullptr;
 
   } else {
     // Check if there is a deployment configuration file. If so, set up the
     // pref config machinery, which will actually read the file.
     nsAutoCString lockFileName;
     nsresult rv = Preferences::GetCString(
       "general.config.filename", lockFileName, PrefValueKind::User);
     if (NS_SUCCEEDED(rv)) {
@@ -3615,19 +3615,19 @@ NS_INTERFACE_MAP_BEGIN(Preferences)
   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
 NS_INTERFACE_MAP_END
 
 //
 // nsIPrefService Implementation
 //
 
 /* static */ void
-Preferences::SetInitPreferences(nsTArray<PrefSetting>* aPrefs)
+Preferences::SetInitPreferences(nsTArray<PrefSetting>* aSettings)
 {
-  gInitPrefs = new InfallibleTArray<PrefSetting>(mozilla::Move(*aPrefs));
+  gInitSettings = new InfallibleTArray<PrefSetting>(mozilla::Move(*aSettings));
 }
 
 /* static */ void
 Preferences::InitializeUserPrefs()
 {
   MOZ_ASSERT(!sPreferences->mCurrentFile, "Should only initialize prefs once");
 
   // Prefs which are set before we initialize the profile are silently
@@ -3794,21 +3794,21 @@ Preferences::SetValueFromDom(const char*
         aPrefName, aValue.get_bool(), aKind);
 
     default:
       MOZ_CRASH();
   }
 }
 
 void
-Preferences::SetPreference(const PrefSetting& aPref)
+Preferences::SetPreference(const PrefSetting& aSetting)
 {
-  const char* prefName = aPref.name().get();
-  const dom::MaybePrefValue& defaultValue = aPref.defaultValue();
-  const dom::MaybePrefValue& userValue = aPref.userValue();
+  const char* prefName = aSetting.name().get();
+  const dom::MaybePrefValue& defaultValue = aSetting.defaultValue();
+  const dom::MaybePrefValue& userValue = aSetting.userValue();
 
   if (defaultValue.type() == dom::MaybePrefValue::TPrefValue) {
     nsresult rv = SetValueFromDom(
       prefName, defaultValue.get_PrefValue(), PrefValueKind::Default);
     if (NS_FAILED(rv)) {
       return;
     }
   }
@@ -3819,41 +3819,41 @@ Preferences::SetPreference(const PrefSet
     PREF_ClearUserPref(prefName);
   }
 
   // NB: we should never try to clear a default value, that doesn't
   // make sense
 }
 
 void
-Preferences::GetPreference(PrefSetting* aPref)
+Preferences::GetPreference(PrefSetting* aSetting)
 {
-  PrefHashEntry* entry = pref_HashTableLookup(aPref->name().get());
-  if (!entry) {
+  PrefHashEntry* pref = pref_HashTableLookup(aSetting->name().get());
+  if (!pref) {
     return;
   }
 
-  if (pref_EntryHasAdvisablySizedValues(entry)) {
-    pref_GetPrefFromEntry(entry, aPref);
+  if (pref_EntryHasAdvisablySizedValues(pref)) {
+    pref_GetPrefFromEntry(pref, aSetting);
   }
 }
 
 void
-Preferences::GetPreferences(InfallibleTArray<PrefSetting>* aPrefs)
+Preferences::GetPreferences(InfallibleTArray<PrefSetting>* aSettings)
 {
-  aPrefs->SetCapacity(gHashTable->Capacity());
+  aSettings->SetCapacity(gHashTable->Capacity());
   for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
-    auto entry = static_cast<PrefHashEntry*>(iter.Get());
-
-    if (!pref_EntryHasAdvisablySizedValues(entry)) {
+    auto pref = static_cast<PrefHashEntry*>(iter.Get());
+
+    if (!pref_EntryHasAdvisablySizedValues(pref)) {
       continue;
     }
 
-    dom::PrefSetting* pref = aPrefs->AppendElement();
-    pref_GetPrefFromEntry(entry, pref);
+    dom::PrefSetting* setting = aSettings->AppendElement();
+    pref_GetPrefFromEntry(pref, setting);
   }
 }
 
 #ifdef DEBUG
 void
 Preferences::SetInitPhase(pref_initPhase aPhase)
 {
   gPhase = aPhase;

--- a/modules/libpref/Preferences.h
+++ b/modules/libpref/Preferences.h
@@ -325,18 +325,18 @@ public:
                                         const char* aPref,
                                         uint32_t aDefault = 0);
   static nsresult AddFloatVarCache(float* aVariable,
                                    const char* aPref,
                                    float aDefault = 0.0f);
 
   // When a content process is created these methods are used to pass prefs in
   // bulk from the parent process.
-  static void GetPreferences(InfallibleTArray<PrefSetting>* aPrefs);
-  static void SetInitPreferences(nsTArray<PrefSetting>* aPrefs);
+  static void GetPreferences(InfallibleTArray<PrefSetting>* aSettings);
+  static void SetInitPreferences(nsTArray<PrefSetting>* aSettings);
 
   // When a pref is changed in the parent process, these methods are used to
   // pass the update to content processes.
   static void GetPreference(PrefSetting* aPref);
   static void SetPreference(const PrefSetting& aPref);
 
 #ifdef DEBUG
   static void SetInitPhase(pref_initPhase phase);