--- a/modules/libpref/prefapi.cpp
+++ b/modules/libpref/prefapi.cpp
@@ -11,17 +11,17 @@
#include "prefapi.h"
#include "prefapi_private_data.h"
#include "prefread.h"
#include "MainThreadUtils.h"
#include "nsReadableUtils.h"
#include "nsCRT.h"
#ifdef _WIN32
- #include "windows.h"
+#include "windows.h"
#endif /* _WIN32 */
#include "plstr.h"
#include "PLDHashTable.h"
#include "plbase64.h"
#include "mozilla/ArenaAllocator.h"
#include "mozilla/ArenaAllocatorExtensions.h"
#include "mozilla/Logging.h"
@@ -32,63 +32,62 @@
#include "nsQuickSort.h"
#include "nsString.h"
#include "nsPrintfCString.h"
#include "prlink.h"
using namespace mozilla;
static void
-clearPrefEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
+clearPrefEntry(PLDHashTable* table, PLDHashEntryHdr* entry)
{
- PrefHashEntry *pref = static_cast<PrefHashEntry *>(entry);
- if (pref->prefFlags.IsTypeString())
- {
- if (pref->defaultPref.stringVal)
- PL_strfree(pref->defaultPref.stringVal);
- if (pref->userPref.stringVal)
- PL_strfree(pref->userPref.stringVal);
- }
- // don't need to free this as it's allocated in memory owned by
- // gPrefNameArena
- pref->key = nullptr;
- memset(entry, 0, table->EntrySize());
+ PrefHashEntry* pref = static_cast<PrefHashEntry*>(entry);
+ if (pref->prefFlags.IsTypeString()) {
+ if (pref->defaultPref.stringVal)
+ PL_strfree(pref->defaultPref.stringVal);
+ if (pref->userPref.stringVal)
+ PL_strfree(pref->userPref.stringVal);
+ }
+ // don't need to free this as it's allocated in memory owned by
+ // gPrefNameArena
+ pref->key = nullptr;
+ memset(entry, 0, table->EntrySize());
}
static bool
matchPrefEntry(const PLDHashEntryHdr* entry, const void* key)
{
- const PrefHashEntry *prefEntry =
- static_cast<const PrefHashEntry*>(entry);
+ const PrefHashEntry* prefEntry = static_cast<const PrefHashEntry*>(entry);
- if (prefEntry->key == key) return true;
+ if (prefEntry->key == key)
+ return true;
- if (!prefEntry->key || !key) return false;
+ if (!prefEntry->key || !key)
+ return false;
- const char *otherKey = reinterpret_cast<const char*>(key);
- return (strcmp(prefEntry->key, otherKey) == 0);
+ const char* otherKey = reinterpret_cast<const char*>(key);
+ return (strcmp(prefEntry->key, otherKey) == 0);
}
-PLDHashTable* gHashTable;
-static ArenaAllocator<8192,4> gPrefNameArena;
+PLDHashTable* gHashTable;
+static ArenaAllocator<8192, 4> gPrefNameArena;
static struct CallbackNode* gFirstCallback = nullptr;
static struct CallbackNode* gLastPriorityNode = nullptr;
-static bool gIsAnyPrefLocked = false;
+static bool gIsAnyPrefLocked = false;
// These are only used during the call to pref_DoCallback
-static bool gCallbacksInProgress = false;
-static bool gShouldCleanupDeadNodes = false;
-
+static bool gCallbacksInProgress = false;
+static bool gShouldCleanupDeadNodes = false;
-static PLDHashTableOps pref_HashTableOps = {
- PLDHashTable::HashStringKey,
- matchPrefEntry,
- PLDHashTable::MoveEntryStub,
- clearPrefEntry,
- nullptr,
+static PLDHashTableOps pref_HashTableOps = {
+ PLDHashTable::HashStringKey,
+ matchPrefEntry,
+ PLDHashTable::MoveEntryStub,
+ clearPrefEntry,
+ nullptr,
};
// PR_ALIGN_OF_WORD is only defined on some platforms. ALIGN_OF_WORD has
// already been defined to PR_ALIGN_OF_WORD everywhere
#ifndef PR_ALIGN_OF_WORD
#define PR_ALIGN_OF_WORD PR_ALIGN_OF_POINTER
#endif
@@ -96,949 +95,965 @@ static PLDHashTableOps pref_HashTabl
// sanity checking
#if (PR_ALIGN_OF_WORD & WORD_ALIGN_MASK) != 0
#error "PR_ALIGN_OF_WORD must be a power of 2!"
#endif
static PrefsDirtyFunc gDirtyCallback = nullptr;
-inline void MakeDirtyCallback()
+inline void
+MakeDirtyCallback()
{
- // Right now the callback function is always set, so we don't need
- // to complicate the code to cover the scenario where we set the callback
- // after we've already tried to make it dirty. If this assert triggers
- // we will add that code.
- MOZ_ASSERT(gDirtyCallback);
- if (gDirtyCallback) {
- gDirtyCallback();
- }
+ // Right now the callback function is always set, so we don't need
+ // to complicate the code to cover the scenario where we set the callback
+ // after we've already tried to make it dirty. If this assert triggers
+ // we will add that code.
+ MOZ_ASSERT(gDirtyCallback);
+ if (gDirtyCallback) {
+ gDirtyCallback();
+ }
}
-void PREF_SetDirtyCallback(PrefsDirtyFunc aFunc)
+void
+PREF_SetDirtyCallback(PrefsDirtyFunc aFunc)
{
- gDirtyCallback = aFunc;
+ gDirtyCallback = aFunc;
}
/*---------------------------------------------------------------------------*/
-static bool pref_ValueChanged(PrefValue oldValue, PrefValue newValue, PrefType type);
+static bool
+pref_ValueChanged(PrefValue oldValue, PrefValue newValue, PrefType type);
/* -- Privates */
-struct CallbackNode {
- char* domain;
- // If someone attempts to remove the node from the callback list while
- // pref_DoCallback is running, |func| is set to nullptr. Such nodes will
- // be removed at the end of pref_DoCallback.
- PrefChangedFunc func;
- void* data;
- struct CallbackNode* next;
+struct CallbackNode
+{
+ char* domain;
+ // If someone attempts to remove the node from the callback list while
+ // pref_DoCallback is running, |func| is set to nullptr. Such nodes will
+ // be removed at the end of pref_DoCallback.
+ PrefChangedFunc func;
+ void* data;
+ struct CallbackNode* next;
};
/* -- Prototypes */
-static nsresult pref_DoCallback(const char* changed_pref);
-
-enum {
- kPrefSetDefault = 1,
- kPrefForceSet = 2,
- kPrefStickyDefault = 4,
-};
-static nsresult pref_HashPref(const char *key, PrefValue value, PrefType type, uint32_t flags);
+static nsresult
+pref_DoCallback(const char* changed_pref);
-#define PREF_HASHTABLE_INITIAL_LENGTH 1024
-
-void PREF_Init()
+enum
{
- if (!gHashTable) {
- gHashTable = new PLDHashTable(&pref_HashTableOps,
- sizeof(PrefHashEntry),
- PREF_HASHTABLE_INITIAL_LENGTH);
- }
+ kPrefSetDefault = 1,
+ kPrefForceSet = 2,
+ kPrefStickyDefault = 4,
+};
+static nsresult
+pref_HashPref(const char* key, PrefValue value, PrefType type, uint32_t flags);
+
+#define PREF_HASHTABLE_INITIAL_LENGTH 1024
+
+void
+PREF_Init()
+{
+ if (!gHashTable) {
+ gHashTable = new PLDHashTable(
+ &pref_HashTableOps, sizeof(PrefHashEntry), PREF_HASHTABLE_INITIAL_LENGTH);
+ }
}
/* Frees the callback list. */
-void PREF_Cleanup()
+void
+PREF_Cleanup()
{
- NS_ASSERTION(!gCallbacksInProgress,
- "PREF_Cleanup was called while gCallbacksInProgress is true!");
- struct CallbackNode* node = gFirstCallback;
- struct CallbackNode* next_node;
+ NS_ASSERTION(!gCallbacksInProgress,
+ "PREF_Cleanup was called while gCallbacksInProgress is true!");
+ struct CallbackNode* node = gFirstCallback;
+ struct CallbackNode* next_node;
- while (node)
- {
- next_node = node->next;
- PL_strfree(node->domain);
- free(node);
- node = next_node;
- }
- gLastPriorityNode = gFirstCallback = nullptr;
+ while (node) {
+ next_node = node->next;
+ PL_strfree(node->domain);
+ free(node);
+ node = next_node;
+ }
+ gLastPriorityNode = gFirstCallback = nullptr;
- PREF_CleanupPrefs();
+ PREF_CleanupPrefs();
}
/* Frees up all the objects except the callback list. */
-void PREF_CleanupPrefs()
+void
+PREF_CleanupPrefs()
{
- if (gHashTable) {
- delete gHashTable;
- gHashTable = nullptr;
- gPrefNameArena.Clear();
- }
+ if (gHashTable) {
+ delete gHashTable;
+ gHashTable = nullptr;
+ gPrefNameArena.Clear();
+ }
}
// note that this appends to aResult, and does not assign!
-static void str_escape(const char * original, nsCString& aResult)
+static void
+str_escape(const char* original, nsCString& aResult)
{
- /* JavaScript does not allow quotes, slashes, or line terminators inside
+ /* JavaScript does not allow quotes, slashes, or line terminators inside
* strings so we must escape them. ECMAScript defines four line
* terminators, but we're only worrying about \r and \n here. We currently
* feed our pref script to the JS interpreter as Latin-1 so we won't
* encounter \u2028 (line separator) or \u2029 (paragraph separator).
*
* WARNING: There are hints that we may be moving to storing prefs
* as utf8. If we ever feed them to the JS compiler as UTF8 then
* we'll have to worry about the multibyte sequences that would be
* interpreted as \u2028 and \u2029
*/
- const char *p;
+ const char* p;
- if (original == nullptr)
- return;
+ if (original == nullptr)
+ return;
- /* Paranoid worst case all slashes will free quickly */
- for (p=original; *p; ++p)
- {
- switch (*p)
- {
- case '\n':
- aResult.AppendLiteral("\\n");
- break;
+ /* Paranoid worst case all slashes will free quickly */
+ for (p = original; *p; ++p) {
+ switch (*p) {
+ case '\n':
+ aResult.AppendLiteral("\\n");
+ break;
- case '\r':
- aResult.AppendLiteral("\\r");
- break;
+ case '\r':
+ aResult.AppendLiteral("\\r");
+ break;
- case '\\':
- aResult.AppendLiteral("\\\\");
- break;
+ case '\\':
+ aResult.AppendLiteral("\\\\");
+ break;
- case '\"':
- aResult.AppendLiteral("\\\"");
- break;
+ case '\"':
+ aResult.AppendLiteral("\\\"");
+ break;
- default:
- aResult.Append(*p);
- break;
- }
+ default:
+ aResult.Append(*p);
+ break;
}
+ }
}
/*
** External calls
*/
nsresult
-PREF_SetCharPref(const char *pref_name, const char *value, bool set_default)
+PREF_SetCharPref(const char* pref_name, const char* value, bool set_default)
{
- if ((uint32_t)strlen(value) > MAX_PREF_LENGTH) {
- return NS_ERROR_ILLEGAL_VALUE;
- }
+ if ((uint32_t)strlen(value) > MAX_PREF_LENGTH) {
+ return NS_ERROR_ILLEGAL_VALUE;
+ }
- PrefValue pref;
- pref.stringVal = (char*)value;
+ PrefValue pref;
+ pref.stringVal = (char*)value;
- return pref_HashPref(pref_name, pref, PrefType::String, set_default ? kPrefSetDefault : 0);
+ return pref_HashPref(
+ pref_name, pref, PrefType::String, set_default ? kPrefSetDefault : 0);
}
nsresult
-PREF_SetIntPref(const char *pref_name, int32_t value, bool set_default)
+PREF_SetIntPref(const char* pref_name, int32_t value, bool set_default)
{
- PrefValue pref;
- pref.intVal = value;
+ PrefValue pref;
+ pref.intVal = value;
- return pref_HashPref(pref_name, pref, PrefType::Int, set_default ? kPrefSetDefault : 0);
+ return pref_HashPref(
+ pref_name, pref, PrefType::Int, set_default ? kPrefSetDefault : 0);
}
nsresult
-PREF_SetBoolPref(const char *pref_name, bool value, bool set_default)
+PREF_SetBoolPref(const char* pref_name, bool value, bool set_default)
{
- PrefValue pref;
- pref.boolVal = value;
+ PrefValue pref;
+ pref.boolVal = value;
- return pref_HashPref(pref_name, pref, PrefType::Bool, set_default ? kPrefSetDefault : 0);
+ return pref_HashPref(
+ pref_name, pref, PrefType::Bool, set_default ? kPrefSetDefault : 0);
}
-enum WhichValue { DEFAULT_VALUE, USER_VALUE };
+enum WhichValue
+{
+ DEFAULT_VALUE,
+ USER_VALUE
+};
static nsresult
-SetPrefValue(const char* aPrefName, const dom::PrefValue& aValue,
+SetPrefValue(const char* aPrefName,
+ const dom::PrefValue& aValue,
WhichValue aWhich)
{
- bool setDefault = (aWhich == DEFAULT_VALUE);
- switch (aValue.type()) {
+ bool setDefault = (aWhich == DEFAULT_VALUE);
+ switch (aValue.type()) {
case dom::PrefValue::TnsCString:
- return PREF_SetCharPref(aPrefName, aValue.get_nsCString().get(),
- setDefault);
+ return PREF_SetCharPref(
+ aPrefName, aValue.get_nsCString().get(), setDefault);
case dom::PrefValue::Tint32_t:
- return PREF_SetIntPref(aPrefName, aValue.get_int32_t(),
- setDefault);
+ return PREF_SetIntPref(aPrefName, aValue.get_int32_t(), setDefault);
case dom::PrefValue::Tbool:
- return PREF_SetBoolPref(aPrefName, aValue.get_bool(),
- setDefault);
+ return PREF_SetBoolPref(aPrefName, aValue.get_bool(), setDefault);
default:
- MOZ_CRASH();
- }
+ MOZ_CRASH();
+ }
}
nsresult
pref_SetPref(const dom::PrefSetting& aPref)
{
- const char* prefName = aPref.name().get();
- const dom::MaybePrefValue& defaultValue = aPref.defaultValue();
- const dom::MaybePrefValue& userValue = aPref.userValue();
+ const char* prefName = aPref.name().get();
+ const dom::MaybePrefValue& defaultValue = aPref.defaultValue();
+ const dom::MaybePrefValue& userValue = aPref.userValue();
- nsresult rv;
- if (defaultValue.type() == dom::MaybePrefValue::TPrefValue) {
- rv = SetPrefValue(prefName, defaultValue.get_PrefValue(), DEFAULT_VALUE);
- if (NS_FAILED(rv)) {
- return rv;
- }
+ nsresult rv;
+ if (defaultValue.type() == dom::MaybePrefValue::TPrefValue) {
+ rv = SetPrefValue(prefName, defaultValue.get_PrefValue(), DEFAULT_VALUE);
+ if (NS_FAILED(rv)) {
+ return rv;
}
+ }
- if (userValue.type() == dom::MaybePrefValue::TPrefValue) {
- rv = SetPrefValue(prefName, userValue.get_PrefValue(), USER_VALUE);
- } else {
- rv = PREF_ClearUserPref(prefName);
- }
+ if (userValue.type() == dom::MaybePrefValue::TPrefValue) {
+ rv = SetPrefValue(prefName, userValue.get_PrefValue(), USER_VALUE);
+ } else {
+ rv = PREF_ClearUserPref(prefName);
+ }
- // NB: we should never try to clear a default value, that doesn't
- // make sense
+ // NB: we should never try to clear a default value, that doesn't
+ // make sense
- return rv;
+ return rv;
}
PrefSaveData
pref_savePrefs(PLDHashTable* aTable)
{
- PrefSaveData savedPrefs(aTable->EntryCount());
-
- for (auto iter = aTable->Iter(); !iter.Done(); iter.Next()) {
- auto pref = static_cast<PrefHashEntry*>(iter.Get());
+ PrefSaveData savedPrefs(aTable->EntryCount());
- nsAutoCString prefValue;
- nsAutoCString prefPrefix;
- prefPrefix.AssignLiteral("user_pref(\"");
-
- // where we're getting our pref from
- PrefValue* sourcePref;
+ for (auto iter = aTable->Iter(); !iter.Done(); iter.Next()) {
+ auto pref = static_cast<PrefHashEntry*>(iter.Get());
- if (pref->prefFlags.HasUserValue() &&
- (pref_ValueChanged(pref->defaultPref,
- pref->userPref,
- pref->prefFlags.GetPrefType()) ||
- !(pref->prefFlags.HasDefault()) ||
- pref->prefFlags.HasStickyDefault())) {
- sourcePref = &pref->userPref;
- } else {
- // do not save default prefs that haven't changed
- continue;
- }
+ nsAutoCString prefValue;
+ nsAutoCString prefPrefix;
+ prefPrefix.AssignLiteral("user_pref(\"");
+
+ // where we're getting our pref from
+ PrefValue* sourcePref;
- // strings are in quotes!
- if (pref->prefFlags.IsTypeString()) {
- prefValue = '\"';
- str_escape(sourcePref->stringVal, prefValue);
- prefValue += '\"';
-
- } else if (pref->prefFlags.IsTypeInt()) {
- prefValue.AppendInt(sourcePref->intVal);
+ if (pref->prefFlags.HasUserValue() &&
+ (pref_ValueChanged(
+ pref->defaultPref, pref->userPref, pref->prefFlags.GetPrefType()) ||
+ !(pref->prefFlags.HasDefault()) ||
+ pref->prefFlags.HasStickyDefault())) {
+ sourcePref = &pref->userPref;
+ } else {
+ // do not save default prefs that haven't changed
+ continue;
+ }
- } else if (pref->prefFlags.IsTypeBool()) {
- prefValue = (sourcePref->boolVal) ? "true" : "false";
- }
+ // strings are in quotes!
+ if (pref->prefFlags.IsTypeString()) {
+ prefValue = '\"';
+ str_escape(sourcePref->stringVal, prefValue);
+ prefValue += '\"';
- nsAutoCString prefName;
- str_escape(pref->key, prefName);
+ } else if (pref->prefFlags.IsTypeInt()) {
+ prefValue.AppendInt(sourcePref->intVal);
- savedPrefs.AppendElement()->
- reset(ToNewCString(prefPrefix +
- prefName +
- NS_LITERAL_CSTRING("\", ") +
- prefValue +
- NS_LITERAL_CSTRING(");")));
+ } else if (pref->prefFlags.IsTypeBool()) {
+ prefValue = (sourcePref->boolVal) ? "true" : "false";
}
- return savedPrefs;
+
+ nsAutoCString prefName;
+ str_escape(pref->key, prefName);
+
+ savedPrefs.AppendElement()->reset(
+ ToNewCString(prefPrefix + prefName + NS_LITERAL_CSTRING("\", ") +
+ prefValue + NS_LITERAL_CSTRING(");")));
+ }
+ return savedPrefs;
}
bool
pref_EntryHasAdvisablySizedValues(PrefHashEntry* aHashEntry)
{
- if (aHashEntry->prefFlags.GetPrefType() != PrefType::String) {
- return true;
- }
+ if (aHashEntry->prefFlags.GetPrefType() != PrefType::String) {
+ return true;
+ }
- char* stringVal;
- if (aHashEntry->prefFlags.HasDefault()) {
- stringVal = aHashEntry->defaultPref.stringVal;
- if (strlen(stringVal) > MAX_ADVISABLE_PREF_LENGTH) {
- return false;
- }
+ char* stringVal;
+ if (aHashEntry->prefFlags.HasDefault()) {
+ stringVal = aHashEntry->defaultPref.stringVal;
+ if (strlen(stringVal) > MAX_ADVISABLE_PREF_LENGTH) {
+ return false;
}
+ }
- if (aHashEntry->prefFlags.HasUserValue()) {
- stringVal = aHashEntry->userPref.stringVal;
- if (strlen(stringVal) > MAX_ADVISABLE_PREF_LENGTH) {
- return false;
- }
+ if (aHashEntry->prefFlags.HasUserValue()) {
+ stringVal = aHashEntry->userPref.stringVal;
+ if (strlen(stringVal) > MAX_ADVISABLE_PREF_LENGTH) {
+ return false;
}
+ }
- return true;
+ return true;
}
static void
-GetPrefValueFromEntry(PrefHashEntry *aHashEntry, dom::PrefSetting* aPref,
+GetPrefValueFromEntry(PrefHashEntry* aHashEntry,
+ dom::PrefSetting* aPref,
WhichValue aWhich)
{
- PrefValue* value;
- dom::PrefValue* settingValue;
- if (aWhich == USER_VALUE) {
- value = &aHashEntry->userPref;
- aPref->userValue() = dom::PrefValue();
- settingValue = &aPref->userValue().get_PrefValue();
- } else {
- value = &aHashEntry->defaultPref;
- aPref->defaultValue() = dom::PrefValue();
- settingValue = &aPref->defaultValue().get_PrefValue();
- }
+ PrefValue* value;
+ dom::PrefValue* settingValue;
+ if (aWhich == USER_VALUE) {
+ value = &aHashEntry->userPref;
+ aPref->userValue() = dom::PrefValue();
+ settingValue = &aPref->userValue().get_PrefValue();
+ } else {
+ value = &aHashEntry->defaultPref;
+ aPref->defaultValue() = dom::PrefValue();
+ settingValue = &aPref->defaultValue().get_PrefValue();
+ }
- switch (aHashEntry->prefFlags.GetPrefType()) {
- case PrefType::String:
- *settingValue = nsDependentCString(value->stringVal);
- return;
- case PrefType::Int:
- *settingValue = value->intVal;
- return;
- case PrefType::Bool:
- *settingValue = !!value->boolVal;
- return;
+ switch (aHashEntry->prefFlags.GetPrefType()) {
+ case PrefType::String:
+ *settingValue = nsDependentCString(value->stringVal);
+ return;
+ case PrefType::Int:
+ *settingValue = value->intVal;
+ return;
+ case PrefType::Bool:
+ *settingValue = !!value->boolVal;
+ return;
default:
- MOZ_CRASH();
- }
+ MOZ_CRASH();
+ }
}
void
-pref_GetPrefFromEntry(PrefHashEntry *aHashEntry, dom::PrefSetting* aPref)
+pref_GetPrefFromEntry(PrefHashEntry* aHashEntry, dom::PrefSetting* aPref)
{
- aPref->name() = aHashEntry->key;
- if (aHashEntry->prefFlags.HasDefault()) {
- GetPrefValueFromEntry(aHashEntry, aPref, DEFAULT_VALUE);
+ aPref->name() = aHashEntry->key;
+ if (aHashEntry->prefFlags.HasDefault()) {
+ GetPrefValueFromEntry(aHashEntry, aPref, DEFAULT_VALUE);
+ } else {
+ aPref->defaultValue() = null_t();
+ }
+ if (aHashEntry->prefFlags.HasUserValue()) {
+ GetPrefValueFromEntry(aHashEntry, aPref, USER_VALUE);
+ } 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()));
+}
+
+bool
+PREF_HasUserPref(const char* pref_name)
+{
+ if (!gHashTable)
+ return false;
+
+ PrefHashEntry* pref = pref_HashTableLookup(pref_name);
+ return pref && pref->prefFlags.HasUserValue();
+}
+
+nsresult
+PREF_CopyCharPref(const char* pref_name, char** return_buffer, bool get_default)
+{
+ if (!gHashTable)
+ return NS_ERROR_NOT_INITIALIZED;
+
+ nsresult rv = NS_ERROR_UNEXPECTED;
+ char* stringVal;
+ PrefHashEntry* pref = pref_HashTableLookup(pref_name);
+
+ if (pref && (pref->prefFlags.IsTypeString())) {
+ if (get_default || pref->prefFlags.IsLocked() ||
+ !pref->prefFlags.HasUserValue()) {
+ stringVal = pref->defaultPref.stringVal;
} else {
- aPref->defaultValue() = null_t();
- }
- if (aHashEntry->prefFlags.HasUserValue()) {
- GetPrefValueFromEntry(aHashEntry, aPref, USER_VALUE);
- } else {
- aPref->userValue() = null_t();
+ stringVal = pref->userPref.stringVal;
}
- 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()));
-}
-
-bool PREF_HasUserPref(const char *pref_name)
-{
- if (!gHashTable)
- return false;
-
- PrefHashEntry *pref = pref_HashTableLookup(pref_name);
- return pref && pref->prefFlags.HasUserValue();
+ if (stringVal) {
+ *return_buffer = NS_strdup(stringVal);
+ rv = NS_OK;
+ }
+ }
+ return rv;
}
nsresult
-PREF_CopyCharPref(const char *pref_name, char ** return_buffer, bool get_default)
+PREF_GetIntPref(const char* pref_name, int32_t* return_int, bool get_default)
{
- if (!gHashTable)
- return NS_ERROR_NOT_INITIALIZED;
-
- nsresult rv = NS_ERROR_UNEXPECTED;
- char* stringVal;
- PrefHashEntry* pref = pref_HashTableLookup(pref_name);
-
- if (pref && (pref->prefFlags.IsTypeString())) {
- if (get_default || pref->prefFlags.IsLocked() || !pref->prefFlags.HasUserValue()) {
- stringVal = pref->defaultPref.stringVal;
- } else {
- stringVal = pref->userPref.stringVal;
- }
-
- if (stringVal) {
- *return_buffer = NS_strdup(stringVal);
- rv = NS_OK;
- }
- }
- return rv;
-}
-
-nsresult PREF_GetIntPref(const char *pref_name,int32_t * return_int, bool get_default)
-{
- if (!gHashTable)
- return NS_ERROR_NOT_INITIALIZED;
+ if (!gHashTable)
+ return NS_ERROR_NOT_INITIALIZED;
- nsresult rv = NS_ERROR_UNEXPECTED;
- PrefHashEntry* pref = pref_HashTableLookup(pref_name);
- if (pref && (pref->prefFlags.IsTypeInt())) {
- if (get_default || pref->prefFlags.IsLocked() || !pref->prefFlags.HasUserValue()) {
- int32_t tempInt = pref->defaultPref.intVal;
- /* check to see if we even had a default */
- if (!pref->prefFlags.HasDefault()) {
- return NS_ERROR_UNEXPECTED;
- }
- *return_int = tempInt;
- } else {
- *return_int = pref->userPref.intVal;
- }
- rv = NS_OK;
+ nsresult rv = NS_ERROR_UNEXPECTED;
+ PrefHashEntry* pref = pref_HashTableLookup(pref_name);
+ if (pref && (pref->prefFlags.IsTypeInt())) {
+ if (get_default || pref->prefFlags.IsLocked() ||
+ !pref->prefFlags.HasUserValue()) {
+ int32_t tempInt = pref->defaultPref.intVal;
+ /* check to see if we even had a default */
+ if (!pref->prefFlags.HasDefault()) {
+ return NS_ERROR_UNEXPECTED;
+ }
+ *return_int = tempInt;
+ } else {
+ *return_int = pref->userPref.intVal;
}
- return rv;
-}
-
-nsresult PREF_GetBoolPref(const char *pref_name, bool * return_value, bool get_default)
-{
- if (!gHashTable)
- return NS_ERROR_NOT_INITIALIZED;
-
- nsresult rv = NS_ERROR_UNEXPECTED;
- PrefHashEntry* pref = pref_HashTableLookup(pref_name);
- //NS_ASSERTION(pref, pref_name);
- if (pref && (pref->prefFlags.IsTypeBool())) {
- if (get_default || pref->prefFlags.IsLocked() || !pref->prefFlags.HasUserValue()) {
- bool tempBool = pref->defaultPref.boolVal;
- /* check to see if we even had a default */
- if (pref->prefFlags.HasDefault()) {
- *return_value = tempBool;
- rv = NS_OK;
- }
- } else {
- *return_value = pref->userPref.boolVal;
- rv = NS_OK;
- }
- }
- return rv;
+ rv = NS_OK;
+ }
+ return rv;
}
nsresult
-PREF_DeleteBranch(const char *branch_name)
+PREF_GetBoolPref(const char* pref_name, bool* return_value, bool get_default)
{
- MOZ_ASSERT(NS_IsMainThread());
+ if (!gHashTable)
+ return NS_ERROR_NOT_INITIALIZED;
- int len = (int)strlen(branch_name);
+ nsresult rv = NS_ERROR_UNEXPECTED;
+ PrefHashEntry* pref = pref_HashTableLookup(pref_name);
+ //NS_ASSERTION(pref, pref_name);
+ if (pref && (pref->prefFlags.IsTypeBool())) {
+ if (get_default || pref->prefFlags.IsLocked() ||
+ !pref->prefFlags.HasUserValue()) {
+ bool tempBool = pref->defaultPref.boolVal;
+ /* check to see if we even had a default */
+ if (pref->prefFlags.HasDefault()) {
+ *return_value = tempBool;
+ rv = NS_OK;
+ }
+ } else {
+ *return_value = pref->userPref.boolVal;
+ rv = NS_OK;
+ }
+ }
+ return rv;
+}
- if (!gHashTable)
- return NS_ERROR_NOT_INITIALIZED;
+nsresult
+PREF_DeleteBranch(const char* branch_name)
+{
+ MOZ_ASSERT(NS_IsMainThread());
- /* The following check insures that if the branch name already has a "."
+ int len = (int)strlen(branch_name);
+
+ if (!gHashTable)
+ return NS_ERROR_NOT_INITIALIZED;
+
+ /* The following check insures that if the branch name already has a "."
* at the end, we don't end up with a "..". This fixes an incompatibility
* between nsIPref, which needs the period added, and nsIPrefBranch which
* does not. When nsIPref goes away this function should be fixed to
* never add the period at all.
*/
- nsAutoCString branch_dot(branch_name);
- if ((len > 1) && branch_name[len - 1] != '.')
- branch_dot += '.';
+ nsAutoCString branch_dot(branch_name);
+ if ((len > 1) && branch_name[len - 1] != '.')
+ branch_dot += '.';
+
+ /* Delete a branch. Used for deleting mime types */
+ const char* to_delete = branch_dot.get();
+ MOZ_ASSERT(to_delete);
+ len = strlen(to_delete);
+ for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
+ auto entry = static_cast<PrefHashEntry*>(iter.Get());
- /* Delete a branch. Used for deleting mime types */
- const char *to_delete = branch_dot.get();
- MOZ_ASSERT(to_delete);
- len = strlen(to_delete);
- for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
- auto entry = static_cast<PrefHashEntry*>(iter.Get());
+ /* note if we're deleting "ldap" then we want to delete "ldap.xxx"
+ and "ldap" (if such a leaf node exists) but not "ldap_1.xxx" */
+ if (PL_strncmp(entry->key, to_delete, (uint32_t)len) == 0 ||
+ (len - 1 == (int)strlen(entry->key) &&
+ PL_strncmp(entry->key, to_delete, (uint32_t)(len - 1)) == 0)) {
+ iter.Remove();
+ }
+ }
+
+ MakeDirtyCallback();
+ return NS_OK;
+}
- /* note if we're deleting "ldap" then we want to delete "ldap.xxx"
- and "ldap" (if such a leaf node exists) but not "ldap_1.xxx" */
- if (PL_strncmp(entry->key, to_delete, (uint32_t) len) == 0 ||
- (len-1 == (int)strlen(entry->key) &&
- PL_strncmp(entry->key, to_delete, (uint32_t)(len-1)) == 0)) {
- iter.Remove();
- }
+nsresult
+PREF_ClearUserPref(const char* pref_name)
+{
+ if (!gHashTable)
+ return NS_ERROR_NOT_INITIALIZED;
+
+ PrefHashEntry* pref = pref_HashTableLookup(pref_name);
+ if (pref && pref->prefFlags.HasUserValue()) {
+ pref->prefFlags.SetHasUserValue(false);
+
+ if (!pref->prefFlags.HasDefault()) {
+ gHashTable->RemoveEntry(pref);
}
+ pref_DoCallback(pref_name);
MakeDirtyCallback();
- return NS_OK;
-}
-
-
-nsresult
-PREF_ClearUserPref(const char *pref_name)
-{
- if (!gHashTable)
- return NS_ERROR_NOT_INITIALIZED;
-
- PrefHashEntry* pref = pref_HashTableLookup(pref_name);
- if (pref && pref->prefFlags.HasUserValue()) {
- pref->prefFlags.SetHasUserValue(false);
-
- if (!pref->prefFlags.HasDefault()) {
- gHashTable->RemoveEntry(pref);
- }
-
- pref_DoCallback(pref_name);
- MakeDirtyCallback();
- }
- return NS_OK;
+ }
+ return NS_OK;
}
nsresult
PREF_ClearAllUserPrefs()
{
- MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(NS_IsMainThread());
- if (!gHashTable)
- return NS_ERROR_NOT_INITIALIZED;
+ if (!gHashTable)
+ return NS_ERROR_NOT_INITIALIZED;
- std::vector<std::string> prefStrings;
- for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
- auto pref = static_cast<PrefHashEntry*>(iter.Get());
+ std::vector<std::string> prefStrings;
+ for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
+ auto pref = static_cast<PrefHashEntry*>(iter.Get());
- if (pref->prefFlags.HasUserValue()) {
- prefStrings.push_back(std::string(pref->key));
+ if (pref->prefFlags.HasUserValue()) {
+ prefStrings.push_back(std::string(pref->key));
- pref->prefFlags.SetHasUserValue(false);
- if (!pref->prefFlags.HasDefault()) {
- iter.Remove();
- }
- }
+ pref->prefFlags.SetHasUserValue(false);
+ if (!pref->prefFlags.HasDefault()) {
+ iter.Remove();
+ }
}
+ }
- for (std::string& prefString : prefStrings) {
- pref_DoCallback(prefString.c_str());
- }
+ for (std::string& prefString : prefStrings) {
+ pref_DoCallback(prefString.c_str());
+ }
- MakeDirtyCallback();
- return NS_OK;
+ MakeDirtyCallback();
+ return NS_OK;
}
-nsresult PREF_LockPref(const char *key, bool lockit)
+nsresult
+PREF_LockPref(const char* key, bool lockit)
{
- if (!gHashTable)
- return NS_ERROR_NOT_INITIALIZED;
+ if (!gHashTable)
+ return NS_ERROR_NOT_INITIALIZED;
- PrefHashEntry* pref = pref_HashTableLookup(key);
- if (!pref)
- return NS_ERROR_UNEXPECTED;
+ PrefHashEntry* pref = pref_HashTableLookup(key);
+ if (!pref)
+ return NS_ERROR_UNEXPECTED;
- if (lockit) {
- if (!pref->prefFlags.IsLocked()) {
- pref->prefFlags.SetLocked(true);
- gIsAnyPrefLocked = true;
- pref_DoCallback(key);
- }
- } else {
- if (pref->prefFlags.IsLocked()) {
- pref->prefFlags.SetLocked(false);
- pref_DoCallback(key);
- }
+ if (lockit) {
+ if (!pref->prefFlags.IsLocked()) {
+ pref->prefFlags.SetLocked(true);
+ gIsAnyPrefLocked = true;
+ pref_DoCallback(key);
}
- return NS_OK;
+ } else {
+ if (pref->prefFlags.IsLocked()) {
+ pref->prefFlags.SetLocked(false);
+ pref_DoCallback(key);
+ }
+ }
+ return NS_OK;
}
/*
* Hash table functions
*/
-static bool pref_ValueChanged(PrefValue oldValue, PrefValue newValue, PrefType type)
+static bool
+pref_ValueChanged(PrefValue oldValue, PrefValue newValue, PrefType type)
{
- bool changed = true;
- switch(type) {
- case PrefType::String:
- if (oldValue.stringVal && newValue.stringVal) {
- changed = (strcmp(oldValue.stringVal, newValue.stringVal) != 0);
- }
- break;
- case PrefType::Int:
- changed = oldValue.intVal != newValue.intVal;
- break;
- case PrefType::Bool:
- changed = oldValue.boolVal != newValue.boolVal;
- break;
- case PrefType::Invalid:
- default:
- changed = false;
- break;
- }
- return changed;
+ bool changed = true;
+ switch (type) {
+ case PrefType::String:
+ if (oldValue.stringVal && newValue.stringVal) {
+ changed = (strcmp(oldValue.stringVal, newValue.stringVal) != 0);
+ }
+ break;
+ case PrefType::Int:
+ changed = oldValue.intVal != newValue.intVal;
+ break;
+ case PrefType::Bool:
+ changed = oldValue.boolVal != newValue.boolVal;
+ break;
+ case PrefType::Invalid:
+ default:
+ changed = false;
+ break;
+ }
+ return changed;
}
/*
* Overwrite the type and value of an existing preference. Caller must
* ensure that they are not changing the type of a preference that has
* a default value.
*/
-static PrefTypeFlags pref_SetValue(PrefValue* existingValue, PrefTypeFlags flags,
- PrefValue newValue, PrefType newType)
+static PrefTypeFlags
+pref_SetValue(PrefValue* existingValue,
+ PrefTypeFlags flags,
+ PrefValue newValue,
+ PrefType newType)
{
- if (flags.IsTypeString() && existingValue->stringVal) {
- PL_strfree(existingValue->stringVal);
- }
- flags.SetPrefType(newType);
- if (flags.IsTypeString()) {
- MOZ_ASSERT(newValue.stringVal);
- existingValue->stringVal = newValue.stringVal ? PL_strdup(newValue.stringVal) : nullptr;
- }
- else {
- *existingValue = newValue;
- }
- return flags;
+ if (flags.IsTypeString() && existingValue->stringVal) {
+ PL_strfree(existingValue->stringVal);
+ }
+ flags.SetPrefType(newType);
+ if (flags.IsTypeString()) {
+ MOZ_ASSERT(newValue.stringVal);
+ existingValue->stringVal =
+ newValue.stringVal ? PL_strdup(newValue.stringVal) : nullptr;
+ } else {
+ *existingValue = newValue;
+ }
+ return flags;
}
#ifdef DEBUG
static pref_initPhase gPhase = START;
static bool gWatchingPref = false;
void
pref_SetInitPhase(pref_initPhase phase)
{
- gPhase = phase;
+ gPhase = phase;
}
pref_initPhase
pref_GetInitPhase()
{
- return gPhase;
+ return gPhase;
}
void
pref_SetWatchingPref(bool watching)
{
- gWatchingPref = watching;
+ gWatchingPref = watching;
}
-
struct StringComparator
{
- const char* mKey;
- explicit StringComparator(const char* aKey) : mKey(aKey) {}
- int operator()(const char* string) const {
- return strcmp(mKey, string);
- }
+ const char* mKey;
+ explicit StringComparator(const char* aKey)
+ : mKey(aKey)
+ {
+ }
+ int operator()(const char* string) const { return strcmp(mKey, string); }
};
bool
inInitArray(const char* key)
{
- size_t prefsLen;
- size_t found;
- const char** list = mozilla::dom::ContentPrefs::GetContentPrefs(&prefsLen);
- return BinarySearchIf(list, 0, prefsLen,
- StringComparator(key), &found);
+ size_t prefsLen;
+ size_t found;
+ const char** list = mozilla::dom::ContentPrefs::GetContentPrefs(&prefsLen);
+ return BinarySearchIf(list, 0, prefsLen, StringComparator(key), &found);
}
#endif
-PrefHashEntry* pref_HashTableLookup(const char *key)
+PrefHashEntry*
+pref_HashTableLookup(const char* key)
{
- MOZ_ASSERT(NS_IsMainThread() || mozilla::ServoStyleSet::IsInServoTraversal());
- MOZ_ASSERT((!XRE_IsContentProcess() || gPhase != START),
- "pref access before commandline prefs set");
- /* If you're hitting this assertion, you've added a pref access to start up.
+ MOZ_ASSERT(NS_IsMainThread() || mozilla::ServoStyleSet::IsInServoTraversal());
+ MOZ_ASSERT((!XRE_IsContentProcess() || 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
* and get review from a DOM peer
*/
#ifdef DEBUG
- if (XRE_IsContentProcess() && gPhase <= END_INIT_PREFS &&
- !gWatchingPref && !inInitArray(key)) {
- MOZ_CRASH_UNSAFE_PRINTF("accessing non-init pref %s before the rest of the prefs are sent",
- key);
- }
+ if (XRE_IsContentProcess() && gPhase <= END_INIT_PREFS && !gWatchingPref &&
+ !inInitArray(key)) {
+ MOZ_CRASH_UNSAFE_PRINTF(
+ "accessing non-init pref %s before the rest of the prefs are sent", key);
+ }
#endif
- return static_cast<PrefHashEntry*>(gHashTable->Search(key));
+ return static_cast<PrefHashEntry*>(gHashTable->Search(key));
}
-nsresult pref_HashPref(const char *key, PrefValue value, PrefType type, uint32_t flags)
+nsresult
+pref_HashPref(const char* key, PrefValue value, PrefType type, uint32_t flags)
{
- MOZ_ASSERT(NS_IsMainThread());
-
- if (!gHashTable)
- return NS_ERROR_OUT_OF_MEMORY;
+ MOZ_ASSERT(NS_IsMainThread());
- auto pref = static_cast<PrefHashEntry*>(gHashTable->Add(key, fallible));
- if (!pref)
- return NS_ERROR_OUT_OF_MEMORY;
+ if (!gHashTable)
+ return NS_ERROR_OUT_OF_MEMORY;
- // new entry, better initialize
- if (!pref->key) {
+ auto pref = static_cast<PrefHashEntry*>(gHashTable->Add(key, fallible));
+ if (!pref)
+ return NS_ERROR_OUT_OF_MEMORY;
+
+ // new entry, better initialize
+ if (!pref->key) {
- // initialize the pref entry
- pref->prefFlags.Reset().SetPrefType(type);
- pref->key = ArenaStrdup(key, gPrefNameArena);
- memset(&pref->defaultPref, 0, sizeof(pref->defaultPref));
- memset(&pref->userPref, 0, sizeof(pref->userPref));
- } else if (pref->prefFlags.HasDefault() && !pref->prefFlags.IsPrefType(type)) {
- NS_WARNING(nsPrintfCString("Trying to overwrite value of default pref %s with the wrong type!", key).get());
- return NS_ERROR_UNEXPECTED;
- }
+ // initialize the pref entry
+ pref->prefFlags.Reset().SetPrefType(type);
+ pref->key = ArenaStrdup(key, gPrefNameArena);
+ memset(&pref->defaultPref, 0, sizeof(pref->defaultPref));
+ memset(&pref->userPref, 0, sizeof(pref->userPref));
+ } else if (pref->prefFlags.HasDefault() &&
+ !pref->prefFlags.IsPrefType(type)) {
+ NS_WARNING(
+ nsPrintfCString(
+ "Trying to overwrite value of default pref %s with the wrong type!",
+ key)
+ .get());
+ return NS_ERROR_UNEXPECTED;
+ }
- bool valueChanged = false;
- if (flags & kPrefSetDefault) {
- if (!pref->prefFlags.IsLocked()) {
- /* ?? change of semantics? */
- if (pref_ValueChanged(pref->defaultPref, value, type) ||
- !pref->prefFlags.HasDefault()) {
- pref->prefFlags = pref_SetValue(&pref->defaultPref, pref->prefFlags, value, type).SetHasDefault(true);
- if (flags & kPrefStickyDefault) {
- pref->prefFlags.SetHasStickyDefault(true);
- }
- if (!pref->prefFlags.HasUserValue()) {
- valueChanged = true;
- }
- }
- // What if we change the default to be the same as the user value?
- // Should we clear the user value?
+ bool valueChanged = false;
+ if (flags & kPrefSetDefault) {
+ if (!pref->prefFlags.IsLocked()) {
+ /* ?? change of semantics? */
+ if (pref_ValueChanged(pref->defaultPref, value, type) ||
+ !pref->prefFlags.HasDefault()) {
+ pref->prefFlags =
+ pref_SetValue(&pref->defaultPref, pref->prefFlags, value, type)
+ .SetHasDefault(true);
+ if (flags & kPrefStickyDefault) {
+ pref->prefFlags.SetHasStickyDefault(true);
}
- } else {
- /* If new value is same as the default value and it's not a "sticky"
+ if (!pref->prefFlags.HasUserValue()) {
+ valueChanged = true;
+ }
+ }
+ // What if we change the default to be the same as the user value?
+ // 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->prefFlags.HasDefault()) &&
- !(pref->prefFlags.HasStickyDefault()) &&
- !pref_ValueChanged(pref->defaultPref, value, type) &&
- !(flags & kPrefForceSet)) {
- if (pref->prefFlags.HasUserValue()) {
- /* XXX should we free a user-set string value if there is one? */
- pref->prefFlags.SetHasUserValue(false);
- if (!pref->prefFlags.IsLocked()) {
- MakeDirtyCallback();
- valueChanged = true;
- }
- }
- } else if (!pref->prefFlags.HasUserValue() ||
- !pref->prefFlags.IsPrefType(type) ||
- pref_ValueChanged(pref->userPref, value, type) ) {
- pref->prefFlags = pref_SetValue(&pref->userPref, pref->prefFlags, value, type).SetHasUserValue(true);
- if (!pref->prefFlags.IsLocked()) {
- MakeDirtyCallback();
- valueChanged = true;
- }
+ if ((pref->prefFlags.HasDefault()) &&
+ !(pref->prefFlags.HasStickyDefault()) &&
+ !pref_ValueChanged(pref->defaultPref, value, type) &&
+ !(flags & kPrefForceSet)) {
+ if (pref->prefFlags.HasUserValue()) {
+ /* XXX should we free a user-set string value if there is one? */
+ pref->prefFlags.SetHasUserValue(false);
+ if (!pref->prefFlags.IsLocked()) {
+ MakeDirtyCallback();
+ valueChanged = true;
}
+ }
+ } else if (!pref->prefFlags.HasUserValue() ||
+ !pref->prefFlags.IsPrefType(type) ||
+ pref_ValueChanged(pref->userPref, value, type)) {
+ pref->prefFlags =
+ pref_SetValue(&pref->userPref, pref->prefFlags, value, type)
+ .SetHasUserValue(true);
+ if (!pref->prefFlags.IsLocked()) {
+ MakeDirtyCallback();
+ valueChanged = true;
+ }
}
+ }
- if (valueChanged) {
- return pref_DoCallback(key);
- }
- return NS_OK;
+ if (valueChanged) {
+ return pref_DoCallback(key);
+ }
+ return NS_OK;
}
size_t
pref_SizeOfPrivateData(MallocSizeOf aMallocSizeOf)
{
- size_t n = gPrefNameArena.SizeOfExcludingThis(aMallocSizeOf);
- for (struct CallbackNode* node = gFirstCallback; node; node = node->next) {
- n += aMallocSizeOf(node);
- n += aMallocSizeOf(node->domain);
- }
- return n;
+ size_t n = gPrefNameArena.SizeOfExcludingThis(aMallocSizeOf);
+ for (struct CallbackNode* node = gFirstCallback; node; node = node->next) {
+ n += aMallocSizeOf(node);
+ n += aMallocSizeOf(node->domain);
+ }
+ return n;
}
PrefType
-PREF_GetPrefType(const char *pref_name)
+PREF_GetPrefType(const char* pref_name)
{
- if (gHashTable) {
- PrefHashEntry* pref = pref_HashTableLookup(pref_name);
- if (pref) {
- return pref->prefFlags.GetPrefType();
- }
+ if (gHashTable) {
+ PrefHashEntry* pref = pref_HashTableLookup(pref_name);
+ if (pref) {
+ return pref->prefFlags.GetPrefType();
}
- return PrefType::Invalid;
+ }
+ return PrefType::Invalid;
}
/* -- */
bool
-PREF_PrefIsLocked(const char *pref_name)
+PREF_PrefIsLocked(const char* pref_name)
{
- bool result = false;
- if (gIsAnyPrefLocked && gHashTable) {
- PrefHashEntry* pref = pref_HashTableLookup(pref_name);
- if (pref && pref->prefFlags.IsLocked()) {
- result = true;
- }
+ bool result = false;
+ if (gIsAnyPrefLocked && gHashTable) {
+ PrefHashEntry* pref = pref_HashTableLookup(pref_name);
+ if (pref && pref->prefFlags.IsLocked()) {
+ result = true;
}
+ }
- return result;
+ return result;
}
/* Adds a node to the beginning of the callback list. */
void
-PREF_RegisterPriorityCallback(const char *pref_node,
+PREF_RegisterPriorityCallback(const char* pref_node,
PrefChangedFunc callback,
- void * instance_data)
+ void* instance_data)
{
- NS_PRECONDITION(pref_node, "pref_node must not be nullptr");
- NS_PRECONDITION(callback, "callback must not be nullptr");
+ NS_PRECONDITION(pref_node, "pref_node must not be nullptr");
+ NS_PRECONDITION(callback, "callback must not be nullptr");
- struct CallbackNode* node = (struct CallbackNode*) malloc(sizeof(struct CallbackNode));
- if (node)
- {
- node->domain = PL_strdup(pref_node);
- node->func = callback;
- node->data = instance_data;
- node->next = gFirstCallback;
- gFirstCallback = node;
- if (!gLastPriorityNode) {
- gLastPriorityNode = node;
- }
+ struct CallbackNode* node =
+ (struct CallbackNode*)malloc(sizeof(struct CallbackNode));
+ if (node) {
+ node->domain = PL_strdup(pref_node);
+ node->func = callback;
+ node->data = instance_data;
+ node->next = gFirstCallback;
+ gFirstCallback = node;
+ if (!gLastPriorityNode) {
+ gLastPriorityNode = node;
}
+ }
}
/* Adds a node to the end of the callback list. */
void
-PREF_RegisterCallback(const char *pref_node,
- PrefChangedFunc callback,
- void * instance_data)
+PREF_RegisterCallback(const char* pref_node,
+ PrefChangedFunc callback,
+ void* instance_data)
{
- NS_PRECONDITION(pref_node, "pref_node must not be nullptr");
- NS_PRECONDITION(callback, "callback must not be nullptr");
+ NS_PRECONDITION(pref_node, "pref_node must not be nullptr");
+ NS_PRECONDITION(callback, "callback must not be nullptr");
- struct CallbackNode* node = (struct CallbackNode*) malloc(sizeof(struct CallbackNode));
- if (node)
- {
- node->domain = PL_strdup(pref_node);
- node->func = callback;
- node->data = instance_data;
- if (gLastPriorityNode) {
- node->next = gLastPriorityNode->next;
- gLastPriorityNode->next = node;
- } else {
- node->next = gFirstCallback;
- gFirstCallback = node;
- }
+ struct CallbackNode* node =
+ (struct CallbackNode*)malloc(sizeof(struct CallbackNode));
+ if (node) {
+ node->domain = PL_strdup(pref_node);
+ node->func = callback;
+ node->data = instance_data;
+ if (gLastPriorityNode) {
+ node->next = gLastPriorityNode->next;
+ gLastPriorityNode->next = node;
+ } else {
+ node->next = gFirstCallback;
+ gFirstCallback = node;
}
+ }
}
/* Removes |node| from callback list.
Returns the node after the deleted one. */
struct CallbackNode*
pref_RemoveCallbackNode(struct CallbackNode* node,
struct CallbackNode* prev_node)
{
- NS_PRECONDITION(!prev_node || prev_node->next == node, "invalid params");
- NS_PRECONDITION(prev_node || gFirstCallback == node, "invalid params");
+ NS_PRECONDITION(!prev_node || prev_node->next == node, "invalid params");
+ NS_PRECONDITION(prev_node || gFirstCallback == node, "invalid params");
- NS_ASSERTION(!gCallbacksInProgress,
- "modifying the callback list while gCallbacksInProgress is true");
+ NS_ASSERTION(
+ !gCallbacksInProgress,
+ "modifying the callback list while gCallbacksInProgress is true");
- struct CallbackNode* next_node = node->next;
- if (prev_node) {
- prev_node->next = next_node;
- } else {
- gFirstCallback = next_node;
- }
- if (gLastPriorityNode == node) {
- gLastPriorityNode = prev_node;
- }
- PL_strfree(node->domain);
- free(node);
- return next_node;
+ struct CallbackNode* next_node = node->next;
+ if (prev_node) {
+ prev_node->next = next_node;
+ } else {
+ gFirstCallback = next_node;
+ }
+ if (gLastPriorityNode == node) {
+ gLastPriorityNode = prev_node;
+ }
+ PL_strfree(node->domain);
+ free(node);
+ return next_node;
}
/* Deletes a node from the callback list or marks it for deletion. */
nsresult
-PREF_UnregisterCallback(const char *pref_node,
- PrefChangedFunc callback,
- void * instance_data)
+PREF_UnregisterCallback(const char* pref_node,
+ PrefChangedFunc callback,
+ void* instance_data)
{
- nsresult rv = NS_ERROR_FAILURE;
- struct CallbackNode* node = gFirstCallback;
- struct CallbackNode* prev_node = nullptr;
+ nsresult rv = NS_ERROR_FAILURE;
+ struct CallbackNode* node = gFirstCallback;
+ struct CallbackNode* prev_node = nullptr;
- while (node != nullptr)
- {
- if ( node->func == callback &&
- node->data == instance_data &&
- strcmp(node->domain, pref_node) == 0)
- {
- if (gCallbacksInProgress)
- {
- // postpone the node removal until after
- // callbacks enumeration is finished.
- node->func = nullptr;
- gShouldCleanupDeadNodes = true;
- prev_node = node;
- node = node->next;
- }
- else
- {
- node = pref_RemoveCallbackNode(node, prev_node);
- }
- rv = NS_OK;
- }
- else
- {
- prev_node = node;
- node = node->next;
- }
+ while (node != nullptr) {
+ if (node->func == callback && node->data == instance_data &&
+ strcmp(node->domain, pref_node) == 0) {
+ if (gCallbacksInProgress) {
+ // postpone the node removal until after
+ // callbacks enumeration is finished.
+ node->func = nullptr;
+ gShouldCleanupDeadNodes = true;
+ prev_node = node;
+ node = node->next;
+ } else {
+ node = pref_RemoveCallbackNode(node, prev_node);
+ }
+ rv = NS_OK;
+ } else {
+ prev_node = node;
+ node = node->next;
}
- return rv;
+ }
+ return rv;
}
-static nsresult pref_DoCallback(const char* changed_pref)
+static nsresult
+pref_DoCallback(const char* changed_pref)
{
- nsresult rv = NS_OK;
- struct CallbackNode* node;
+ nsresult rv = NS_OK;
+ struct CallbackNode* node;
- bool reentered = gCallbacksInProgress;
- gCallbacksInProgress = true;
- // Nodes must not be deleted while gCallbacksInProgress is true.
- // Nodes that need to be deleted are marked for deletion by nulling
- // out the |func| pointer. We release them at the end of this function
- // if we haven't reentered.
-
- for (node = gFirstCallback; node != nullptr; node = node->next)
- {
- if ( node->func &&
- PL_strncmp(changed_pref,
- node->domain,
- strlen(node->domain)) == 0 )
- {
- (*node->func) (changed_pref, node->data);
- }
- }
+ bool reentered = gCallbacksInProgress;
+ gCallbacksInProgress = true;
+ // Nodes must not be deleted while gCallbacksInProgress is true.
+ // Nodes that need to be deleted are marked for deletion by nulling
+ // out the |func| pointer. We release them at the end of this function
+ // if we haven't reentered.
- gCallbacksInProgress = reentered;
+ for (node = gFirstCallback; node != nullptr; node = node->next) {
+ if (node->func &&
+ PL_strncmp(changed_pref, node->domain, strlen(node->domain)) == 0) {
+ (*node->func)(changed_pref, node->data);
+ }
+ }
- if (gShouldCleanupDeadNodes && !gCallbacksInProgress)
- {
- struct CallbackNode* prev_node = nullptr;
- node = gFirstCallback;
+ gCallbacksInProgress = reentered;
+
+ if (gShouldCleanupDeadNodes && !gCallbacksInProgress) {
+ struct CallbackNode* prev_node = nullptr;
+ node = gFirstCallback;
- while (node != nullptr)
- {
- if (!node->func)
- {
- node = pref_RemoveCallbackNode(node, prev_node);
- }
- else
- {
- prev_node = node;
- node = node->next;
- }
- }
- gShouldCleanupDeadNodes = false;
+ while (node != nullptr) {
+ if (!node->func) {
+ node = pref_RemoveCallbackNode(node, prev_node);
+ } else {
+ prev_node = node;
+ node = node->next;
+ }
}
+ gShouldCleanupDeadNodes = false;
+ }
- return rv;
+ return rv;
}
-void PREF_ReaderCallback(void *closure,
- const char *pref,
- PrefValue value,
- PrefType type,
- bool isDefault,
- bool isStickyDefault)
+void
+PREF_ReaderCallback(void* closure,
+ const char* pref,
+ PrefValue value,
+ PrefType type,
+ bool isDefault,
+ bool isStickyDefault)
{
- uint32_t flags = 0;
- if (isDefault) {
- flags |= kPrefSetDefault;
- if (isStickyDefault) {
- flags |= kPrefStickyDefault;
- }
- } else {
- flags |= kPrefForceSet;
+ uint32_t flags = 0;
+ if (isDefault) {
+ flags |= kPrefSetDefault;
+ if (isStickyDefault) {
+ flags |= kPrefStickyDefault;
}
- pref_HashPref(pref, value, type, flags);
+ } else {
+ flags |= kPrefForceSet;
+ }
+ pref_HashPref(pref, value, type, flags);
}