--- a/modules/libpref/Preferences.cpp
+++ b/modules/libpref/Preferences.cpp
@@ -57,31 +57,29 @@
#include "nsRefPtrHashtable.h"
#include "nsIMemoryReporter.h"
#include "nsThreadUtils.h"
#include "GeckoProfiler.h"
using namespace mozilla;
#ifdef DEBUG
-#define ENSURE_MAIN_PROCESS(message, pref) do { \
- if (MOZ_UNLIKELY(!XRE_IsParentProcess())) { \
- nsPrintfCString msg("ENSURE_MAIN_PROCESS failed. %s %s", message, pref); \
- NS_WARNING(msg.get()); \
- return NS_ERROR_NOT_AVAILABLE; \
- } \
-} while (0);
-class WatchinPrefRAII {
+#define ENSURE_MAIN_PROCESS(message, pref) \
+ do { \
+ if (MOZ_UNLIKELY(!XRE_IsParentProcess())) { \
+ nsPrintfCString msg("ENSURE_MAIN_PROCESS failed. %s %s", message, pref); \
+ NS_WARNING(msg.get()); \
+ return NS_ERROR_NOT_AVAILABLE; \
+ } \
+ } while (0);
+class WatchinPrefRAII
+{
public:
- WatchinPrefRAII() {
- pref_SetWatchingPref(true);
- }
- ~WatchinPrefRAII() {
- pref_SetWatchingPref(false);
- }
+ WatchinPrefRAII() { pref_SetWatchingPref(true); }
+ ~WatchinPrefRAII() { pref_SetWatchingPref(false); }
};
#define WATCHING_PREF_RAII() WatchinPrefRAII watchingPrefRAII
#else
#define ENSURE_MAIN_PROCESS(message, pref) \
if (MOZ_UNLIKELY(!XRE_IsParentProcess())) { \
return NS_ERROR_NOT_AVAILABLE; \
}
#define WATCHING_PREF_RAII()
@@ -109,40 +107,44 @@ Preferences::DirtyCallback()
}
if (sPreferences->mProfileShutdown) {
NS_WARNING("Setting user pref after profile shutdown.");
return;
}
if (!sPreferences->mDirty) {
sPreferences->mDirty = true;
- if (sPreferences->mCurrentFile &&
- sPreferences->AllowOffMainThreadSave()
- && !sPreferences->mSavePending) {
+ if (sPreferences->mCurrentFile && sPreferences->AllowOffMainThreadSave() &&
+ !sPreferences->mSavePending) {
sPreferences->mSavePending = true;
static const int PREF_DELAY_MS = 500;
NS_DelayedDispatchToCurrentThread(
mozilla::NewRunnableMethod("Preferences::SavePrefFileAsynchronous",
sPreferences,
&Preferences::SavePrefFileAsynchronous),
PREF_DELAY_MS);
}
}
}
// Prototypes
-static nsresult openPrefFile(nsIFile* aFile);
-static Result<Ok, const char*> pref_InitInitialObjects();
-static nsresult pref_LoadPrefsInDirList(const char *listId);
-static nsresult ReadExtensionPrefs(nsIFile *aFile);
+static nsresult
+openPrefFile(nsIFile* aFile);
+static Result<Ok, const char*>
+pref_InitInitialObjects();
+static nsresult
+pref_LoadPrefsInDirList(const char* listId);
+static nsresult
+ReadExtensionPrefs(nsIFile* aFile);
static const char kTelemetryPref[] = "toolkit.telemetry.enabled";
static const char kOldTelemetryPref[] = "toolkit.telemetry.enabledPreRelease";
static const char kChannelPref[] = "app.update.channel";
+// clang-format off
static const char kPrefFileHeader[] =
"# Mozilla User Preferences"
NS_LINEBREAK
NS_LINEBREAK
"/* Do not edit this file."
NS_LINEBREAK
" *"
NS_LINEBREAK
@@ -152,147 +154,151 @@ static const char kPrefFileHeader[] =
NS_LINEBREAK
" *"
NS_LINEBREAK
" * To make a manual change to preferences, you can visit the URL about:config"
NS_LINEBREAK
" */"
NS_LINEBREAK
NS_LINEBREAK;
+// clang-format on
Preferences* Preferences::sPreferences = nullptr;
nsIPrefBranch* Preferences::sRootBranch = nullptr;
nsIPrefBranch* Preferences::sDefaultRootBranch = nullptr;
bool Preferences::sShutdown = false;
// This globally enables or disables OMT pref writing, both sync and async
static int32_t sAllowOMTPrefWrite = -1;
-
-class ValueObserverHashKey : public PLDHashEntryHdr {
+class ValueObserverHashKey : public PLDHashEntryHdr
+{
public:
typedef ValueObserverHashKey* KeyType;
typedef const ValueObserverHashKey* KeyTypePointer;
- static const ValueObserverHashKey* KeyToPointer(ValueObserverHashKey *aKey)
+ static const ValueObserverHashKey* KeyToPointer(ValueObserverHashKey* aKey)
{
return aKey;
}
- static PLDHashNumber HashKey(const ValueObserverHashKey *aKey)
+ static PLDHashNumber HashKey(const ValueObserverHashKey* aKey)
{
PLDHashNumber hash = HashString(aKey->mPrefName);
hash = AddToHash(hash, aKey->mMatchKind);
return AddToHash(hash, aKey->mCallback);
}
- ValueObserverHashKey(const char *aPref, PrefChangedFunc aCallback, Preferences::MatchKind aMatchKind) :
- mPrefName(aPref), mCallback(aCallback), mMatchKind(aMatchKind) { }
+ ValueObserverHashKey(const char* aPref,
+ PrefChangedFunc aCallback,
+ Preferences::MatchKind aMatchKind)
+ : mPrefName(aPref)
+ , mCallback(aCallback)
+ , mMatchKind(aMatchKind)
+ {
+ }
- explicit ValueObserverHashKey(const ValueObserverHashKey *aOther) :
- mPrefName(aOther->mPrefName),
- mCallback(aOther->mCallback),
- mMatchKind(aOther->mMatchKind)
- { }
+ explicit ValueObserverHashKey(const ValueObserverHashKey* aOther)
+ : mPrefName(aOther->mPrefName)
+ , mCallback(aOther->mCallback)
+ , mMatchKind(aOther->mMatchKind)
+ {
+ }
- bool KeyEquals(const ValueObserverHashKey *aOther) const
+ bool KeyEquals(const ValueObserverHashKey* aOther) const
{
- return mCallback == aOther->mCallback &&
- mPrefName == aOther->mPrefName &&
+ return mCallback == aOther->mCallback && mPrefName == aOther->mPrefName &&
mMatchKind == aOther->mMatchKind;
}
- ValueObserverHashKey *GetKey() const
+ ValueObserverHashKey* GetKey() const
{
return const_cast<ValueObserverHashKey*>(this);
}
- enum { ALLOW_MEMMOVE = true };
+ enum
+ {
+ ALLOW_MEMMOVE = true
+ };
nsCString mPrefName;
PrefChangedFunc mCallback;
Preferences::MatchKind mMatchKind;
};
-class ValueObserver final : public nsIObserver,
- public ValueObserverHashKey
+class ValueObserver final
+ : public nsIObserver
+ , public ValueObserverHashKey
{
- ~ValueObserver() {
- Preferences::RemoveObserver(this, mPrefName.get());
- }
+ ~ValueObserver() { Preferences::RemoveObserver(this, mPrefName.get()); }
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
- ValueObserver(const char *aPref, PrefChangedFunc aCallback, Preferences::MatchKind aMatchKind)
- : ValueObserverHashKey(aPref, aCallback, aMatchKind) { }
-
- void AppendClosure(void *aClosure) {
- mClosures.AppendElement(aClosure);
+ ValueObserver(const char* aPref,
+ PrefChangedFunc aCallback,
+ Preferences::MatchKind aMatchKind)
+ : ValueObserverHashKey(aPref, aCallback, aMatchKind)
+ {
}
- void RemoveClosure(void *aClosure) {
- mClosures.RemoveElement(aClosure);
- }
+ void AppendClosure(void* aClosure) { mClosures.AppendElement(aClosure); }
- bool HasNoClosures() {
- return mClosures.Length() == 0;
- }
+ void RemoveClosure(void* aClosure) { mClosures.RemoveElement(aClosure); }
+
+ bool HasNoClosures() { return mClosures.Length() == 0; }
nsTArray<void*> mClosures;
};
NS_IMPL_ISUPPORTS(ValueObserver, nsIObserver)
NS_IMETHODIMP
-ValueObserver::Observe(nsISupports *aSubject,
- const char *aTopic,
- const char16_t *aData)
+ValueObserver::Observe(nsISupports* aSubject,
+ const char* aTopic,
+ const char16_t* aData)
{
NS_ASSERTION(!nsCRT::strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID),
"invalid topic");
NS_ConvertUTF16toUTF8 data(aData);
- if (mMatchKind == Preferences::ExactMatch && !mPrefName.EqualsASCII(data.get())) {
+ if (mMatchKind == Preferences::ExactMatch &&
+ !mPrefName.EqualsASCII(data.get())) {
return NS_OK;
}
for (uint32_t i = 0; i < mClosures.Length(); i++) {
mCallback(data.get(), mClosures.ElementAt(i));
}
return NS_OK;
}
// Write the preference data to a file.
//
class PreferencesWriter final
{
public:
- PreferencesWriter()
- {
- }
+ PreferencesWriter() {}
- static
- nsresult Write(nsIFile* aFile, PrefSaveData& aPrefs)
+ static nsresult Write(nsIFile* aFile, PrefSaveData& aPrefs)
{
nsCOMPtr<nsIOutputStream> outStreamSink;
nsCOMPtr<nsIOutputStream> outStream;
- uint32_t writeAmount;
- nsresult rv;
+ uint32_t writeAmount;
+ nsresult rv;
// execute a "safe" save by saving through a tempfile
- rv = NS_NewSafeLocalFileOutputStream(getter_AddRefs(outStreamSink),
- aFile,
- -1,
- 0600);
+ rv = NS_NewSafeLocalFileOutputStream(
+ getter_AddRefs(outStreamSink), aFile, -1, 0600);
if (NS_FAILED(rv)) {
return rv;
}
- rv = NS_NewBufferedOutputStream(getter_AddRefs(outStream), outStreamSink, 4096);
+ rv = NS_NewBufferedOutputStream(
+ getter_AddRefs(outStream), outStreamSink, 4096);
if (NS_FAILED(rv)) {
return rv;
}
struct CharComparator
{
bool LessThan(const mozilla::UniqueFreePtr<char>& a,
const mozilla::UniqueFreePtr<char>& b) const
@@ -305,17 +311,18 @@ public:
return strcmp(a.get(), b.get()) == 0;
}
};
/* Sort the preferences to make a readable file on disk */
aPrefs.Sort(CharComparator());
// write out the file header
- outStream->Write(kPrefFileHeader, sizeof(kPrefFileHeader) - 1, &writeAmount);
+ outStream->Write(
+ kPrefFileHeader, sizeof(kPrefFileHeader) - 1, &writeAmount);
for (auto& prefptr : aPrefs) {
char* pref = prefptr.get();
MOZ_ASSERT(pref);
outStream->Write(pref, strlen(pref), &writeAmount);
outStream->Write(NS_LINEBREAK, NS_LINEBREAK_LEN, &writeAmount);
}
@@ -330,18 +337,17 @@ public:
#ifdef DEBUG
if (NS_FAILED(rv)) {
NS_WARNING("failed to save prefs file! possible data loss");
}
#endif
return rv;
}
- static
- void Flush()
+ static void Flush()
{
// This can be further optimized; instead of waiting for
// all of the writer thread to be available, we just have
// to wait for all the pending writes to be done.
if (!sPendingWriteData.compareExchange(nullptr, nullptr)) {
nsresult rv = NS_OK;
nsCOMPtr<nsIEventTarget> target =
do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
@@ -360,64 +366,69 @@ public:
Atomic<PrefSaveData*> PreferencesWriter::sPendingWriteData(nullptr);
class PWRunnable : public Runnable
{
public:
explicit PWRunnable(nsIFile* aFile)
: Runnable("PWRunnable")
, mFile(aFile)
- {}
+ {
+ }
NS_IMETHOD Run() override
{
- mozilla::UniquePtr<PrefSaveData> prefs(PreferencesWriter::sPendingWriteData.exchange(nullptr));
+ mozilla::UniquePtr<PrefSaveData> prefs(
+ PreferencesWriter::sPendingWriteData.exchange(nullptr));
// If we get a nullptr on the exchange, it means that somebody
// else has already processed the request, and we can just return.
nsresult rv = NS_OK;
if (prefs) {
rv = PreferencesWriter::Write(mFile, *prefs);
// Make a copy of these so we can have them in runnable lambda.
// nsIFile is only there so that we would never release the
// ref counted pointer off main thread.
nsresult rvCopy = rv;
nsCOMPtr<nsIFile> fileCopy(mFile);
- SystemGroup::Dispatch(TaskCategory::Other,
- NS_NewRunnableFunction("Preferences::WriterRunnable", [fileCopy, rvCopy] {
- MOZ_RELEASE_ASSERT(NS_IsMainThread());
- if (NS_FAILED(rvCopy)) {
- Preferences::DirtyCallback();
- }
- }));
+ SystemGroup::Dispatch(
+ TaskCategory::Other,
+ NS_NewRunnableFunction("Preferences::WriterRunnable",
+ [fileCopy, rvCopy] {
+ MOZ_RELEASE_ASSERT(NS_IsMainThread());
+ if (NS_FAILED(rvCopy)) {
+ Preferences::DirtyCallback();
+ }
+ }));
}
return rv;
}
protected:
nsCOMPtr<nsIFile> mFile;
};
-struct CacheData {
+struct CacheData
+{
void* cacheLocation;
union {
bool defaultValueBool;
int32_t defaultValueInt;
uint32_t defaultValueUint;
float defaultValueFloat;
};
};
// gCacheDataDesc holds information about prefs startup. It's being used for
// diagnosing prefs startup problems in bug 1276488.
static const char* gCacheDataDesc = "untouched";
-static nsTArray<nsAutoPtr<CacheData> >* gCacheData = nullptr;
-static nsRefPtrHashtable<ValueObserverHashKey,
- ValueObserver>* gObserverTable = nullptr;
+static nsTArray<nsAutoPtr<CacheData>>* gCacheData = nullptr;
+static nsRefPtrHashtable<ValueObserverHashKey, ValueObserver>* gObserverTable =
+ nullptr;
#ifdef DEBUG
static bool
HaveExistingCacheFor(void* aPtr)
{
MOZ_ASSERT(NS_IsMainThread());
if (gCacheData) {
for (size_t i = 0, count = gCacheData->Length(); i < count; ++i) {
@@ -425,42 +436,47 @@ HaveExistingCacheFor(void* aPtr)
return true;
}
}
}
return false;
}
static void
-AssertNotAlreadyCached(const char* aPrefType,
- const char* aPref,
- void* aPtr)
+AssertNotAlreadyCached(const char* aPrefType, const char* aPref, void* aPtr)
{
if (HaveExistingCacheFor(aPtr)) {
- fprintf_stderr(stderr,
+ fprintf_stderr(
+ stderr,
"Attempt to add a %s pref cache for preference '%s' at address '%p'"
"was made. However, a pref was already cached at this address.\n",
- aPrefType, aPref, aPtr);
- MOZ_ASSERT(false, "Should not have an existing pref cache for this address");
+ aPrefType,
+ aPref,
+ aPtr);
+ MOZ_ASSERT(false,
+ "Should not have an existing pref cache for this address");
}
}
#endif
static void
ReportToConsole(const char* aMessage, int aLine, bool aError)
{
nsPrintfCString message("** Preference parsing %s (line %d) = %s **\n",
- (aError ? "error" : "warning"), aLine, aMessage);
+ (aError ? "error" : "warning"),
+ aLine,
+ aMessage);
nsPrefBranch::ReportToConsole(NS_ConvertUTF8toUTF16(message.get()));
}
// Although this is a member of Preferences, it measures sPreferences and
// several other global structures.
/* static */ int64_t
-Preferences::SizeOfIncludingThisAndOtherStuff(mozilla::MallocSizeOf aMallocSizeOf)
+Preferences::SizeOfIncludingThisAndOtherStuff(
+ mozilla::MallocSizeOf aMallocSizeOf)
{
NS_ENSURE_TRUE(InitStaticMembers(), 0);
size_t n = aMallocSizeOf(sPreferences);
if (gHashTable) {
// pref keys are allocated in a private arena, which we count elsewhere.
// pref stringvals are allocated out of the same private arena.
n += gHashTable->ShallowSizeOfIncludingThis(aMallocSizeOf);
@@ -474,20 +490,22 @@ Preferences::SizeOfIncludingThisAndOther
if (gObserverTable) {
n += gObserverTable->ShallowSizeOfIncludingThis(aMallocSizeOf);
for (auto iter = gObserverTable->Iter(); !iter.Done(); iter.Next()) {
n += iter.Key()->mPrefName.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
n += iter.Data()->mClosures.ShallowSizeOfExcludingThis(aMallocSizeOf);
}
}
if (sRootBranch) {
- n += reinterpret_cast<nsPrefBranch*>(sRootBranch)->SizeOfIncludingThis(aMallocSizeOf);
+ n += reinterpret_cast<nsPrefBranch*>(sRootBranch)
+ ->SizeOfIncludingThis(aMallocSizeOf);
}
if (sDefaultRootBranch) {
- n += reinterpret_cast<nsPrefBranch*>(sDefaultRootBranch)->SizeOfIncludingThis(aMallocSizeOf);
+ n += reinterpret_cast<nsPrefBranch*>(sDefaultRootBranch)
+ ->SizeOfIncludingThis(aMallocSizeOf);
}
n += pref_SizeOfPrivateData(aMallocSizeOf);
return n;
}
class PreferenceServiceReporter final : public nsIMemoryReporter
{
~PreferenceServiceReporter() {}
@@ -501,22 +519,26 @@ protected:
};
NS_IMPL_ISUPPORTS(PreferenceServiceReporter, nsIMemoryReporter)
MOZ_DEFINE_MALLOC_SIZE_OF(PreferenceServiceMallocSizeOf)
NS_IMETHODIMP
PreferenceServiceReporter::CollectReports(
- nsIHandleReportCallback* aHandleReport, nsISupports* aData, bool aAnonymize)
+ nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData,
+ bool aAnonymize)
{
- MOZ_COLLECT_REPORT(
- "explicit/preferences", KIND_HEAP, UNITS_BYTES,
- Preferences::SizeOfIncludingThisAndOtherStuff(PreferenceServiceMallocSizeOf),
- "Memory used by the preferences system.");
+ MOZ_COLLECT_REPORT("explicit/preferences",
+ KIND_HEAP,
+ UNITS_BYTES,
+ Preferences::SizeOfIncludingThisAndOtherStuff(
+ PreferenceServiceMallocSizeOf),
+ "Memory used by the preferences system.");
nsPrefBranch* rootBranch =
static_cast<nsPrefBranch*>(Preferences::GetRootBranch());
if (!rootBranch) {
return NS_OK;
}
size_t numStrong = 0;
@@ -556,52 +578,65 @@ PreferenceServiceReporter::CollectReport
}
for (uint32_t i = 0; i < suspectPreferences.Length(); i++) {
nsCString& suspect = suspectPreferences[i];
uint32_t totalReferentCount = 0;
prefCounter.Get(suspect, &totalReferentCount);
nsPrintfCString suspectPath("preference-service-suspect/"
- "referent(pref=%s)", suspect.get());
+ "referent(pref=%s)",
+ suspect.get());
aHandleReport->Callback(
/* process = */ EmptyCString(),
- suspectPath, KIND_OTHER, UNITS_COUNT, totalReferentCount,
+ suspectPath,
+ KIND_OTHER,
+ UNITS_COUNT,
+ totalReferentCount,
NS_LITERAL_CSTRING(
"A preference with a suspiciously large number referents (symptom of a "
"leak)."),
aData);
}
MOZ_COLLECT_REPORT(
- "preference-service/referent/strong", KIND_OTHER, UNITS_COUNT,
+ "preference-service/referent/strong",
+ KIND_OTHER,
+ UNITS_COUNT,
numStrong,
"The number of strong referents held by the preference service.");
MOZ_COLLECT_REPORT(
- "preference-service/referent/weak/alive", KIND_OTHER, UNITS_COUNT,
+ "preference-service/referent/weak/alive",
+ KIND_OTHER,
+ UNITS_COUNT,
numWeakAlive,
"The number of weak referents held by the preference service that are "
"still alive.");
MOZ_COLLECT_REPORT(
- "preference-service/referent/weak/dead", KIND_OTHER, UNITS_COUNT,
+ "preference-service/referent/weak/dead",
+ KIND_OTHER,
+ UNITS_COUNT,
numWeakDead,
"The number of weak referents held by the preference service that are "
"dead.");
return NS_OK;
}
namespace {
class AddPreferencesMemoryReporterRunnable : public Runnable
{
public:
- AddPreferencesMemoryReporterRunnable() : Runnable("AddPreferencesMemoryReporterRunnable") {}
+ AddPreferencesMemoryReporterRunnable()
+ : Runnable("AddPreferencesMemoryReporterRunnable")
+ {
+ }
NS_IMETHOD Run() override
{
return RegisterStrongMemoryReporter(new PreferenceServiceReporter());
}
};
} // namespace
// static
@@ -629,17 +664,17 @@ Preferences::GetInstanceForService()
Result<Ok, const char*> res = sPreferences->Init();
if (res.isErr()) {
// The singleton instance will delete sRootBranch and sDefaultRootBranch.
gCacheDataDesc = res.unwrapErr();
NS_RELEASE(sPreferences);
return nullptr;
}
- gCacheData = new nsTArray<nsAutoPtr<CacheData> >();
+ gCacheData = new nsTArray<nsAutoPtr<CacheData>>();
gCacheDataDesc = "set by GetInstanceForService()";
gObserverTable = new nsRefPtrHashtable<ValueObserverHashKey, ValueObserver>();
// Preferences::GetInstanceForService() can be called from GetService(), and
// RegisterStrongMemoryReporter calls GetService(nsIMemoryReporter). To
// avoid a potential recursive GetService() call, we can't register the
// memory reporter here; instead, do it off a runnable.
@@ -690,19 +725,17 @@ Preferences::Shutdown()
}
//-----------------------------------------------------------------------------
/*
* Constructor/Destructor
*/
-Preferences::Preferences()
-{
-}
+Preferences::Preferences() {}
Preferences::~Preferences()
{
NS_ASSERTION(sPreferences == this, "Isn't this the singleton instance?");
delete gObserverTable;
gObserverTable = nullptr;
@@ -712,41 +745,41 @@ Preferences::~Preferences()
NS_RELEASE(sRootBranch);
NS_RELEASE(sDefaultRootBranch);
sPreferences = nullptr;
PREF_Cleanup();
}
-
/*
* nsISupports Implementation
*/
NS_IMPL_ADDREF(Preferences)
NS_IMPL_RELEASE(Preferences)
NS_INTERFACE_MAP_BEGIN(Preferences)
- NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIPrefService)
- NS_INTERFACE_MAP_ENTRY(nsIPrefService)
- NS_INTERFACE_MAP_ENTRY(nsIObserver)
- NS_INTERFACE_MAP_ENTRY(nsIPrefBranch)
- NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIPrefService)
+ NS_INTERFACE_MAP_ENTRY(nsIPrefService)
+ NS_INTERFACE_MAP_ENTRY(nsIObserver)
+ NS_INTERFACE_MAP_ENTRY(nsIPrefBranch)
+ NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
NS_INTERFACE_MAP_END
/*
* nsIPrefService Implementation
*/
InfallibleTArray<Preferences::PrefSetting>* gInitPrefs;
/*static*/
void
-Preferences::SetInitPreferences(nsTArray<PrefSetting>* aPrefs) {
+Preferences::SetInitPreferences(nsTArray<PrefSetting>* aPrefs)
+{
gInitPrefs = new InfallibleTArray<PrefSetting>(mozilla::Move(*aPrefs));
}
Result<Ok, const char*>
Preferences::Init()
{
PREF_SetDirtyCallback(&DirtyCallback);
PREF_Init();
@@ -767,22 +800,23 @@ Preferences::Init()
/*
* The following is a small hack which will allow us to only load the library
* which supports the netscape.cfg file if the preference is defined. We
* test for the existence of the pref, set in the all.js (mozilla) or
* all-ns.js (netscape 6), and if it exists we startup the pref config
* category which will do the rest.
*/
- nsresult rv = PREF_CopyCharPref("general.config.filename",
- getter_Copies(lockFileName), false);
+ nsresult rv = PREF_CopyCharPref(
+ "general.config.filename", getter_Copies(lockFileName), false);
if (NS_SUCCEEDED(rv))
- NS_CreateServicesFromCategory("pref-config-startup",
- static_cast<nsISupports *>(static_cast<void *>(this)),
- "pref-config-startup");
+ NS_CreateServicesFromCategory(
+ "pref-config-startup",
+ static_cast<nsISupports*>(static_cast<void*>(this)),
+ "pref-config-startup");
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
if (!observerService) {
return Err("GetObserverService() failed (1)");
}
observerService->AddObserver(this, "profile-before-change-telemetry", true);
@@ -821,18 +855,19 @@ Preferences::InitializeUserPrefs()
Preferences::SetBool(kTelemetryPref, false);
Preferences::ClearUser(kOldTelemetryPref);
}
sPreferences->NotifyServiceObservers(NS_PREFSERVICE_READ_TOPIC_ID);
}
NS_IMETHODIMP
-Preferences::Observe(nsISupports *aSubject, const char *aTopic,
- const char16_t *someData)
+Preferences::Observe(nsISupports* aSubject,
+ const char* aTopic,
+ const char16_t* someData)
{
if (MOZ_UNLIKELY(!XRE_IsParentProcess())) {
return NS_ERROR_NOT_AVAILABLE;
}
nsresult rv = NS_OK;
if (!nsCRT::strcmp(aTopic, "profile-before-change")) {
@@ -858,19 +893,18 @@ Preferences::Observe(nsISupports *aSubje
// Our process is being suspended. The OS may wake our process later,
// or it may kill the process. In case our process is going to be killed
// from the suspended state, we save preferences before suspending.
rv = SavePrefFileBlocking();
}
return rv;
}
-
NS_IMETHODIMP
-Preferences::ReadUserPrefsFromFile(nsIFile *aFile)
+Preferences::ReadUserPrefsFromFile(nsIFile* aFile)
{
if (MOZ_UNLIKELY(!XRE_IsParentProcess())) {
NS_ERROR("must load prefs from parent process");
return NS_ERROR_NOT_AVAILABLE;
}
if (!aFile) {
NS_ERROR("ReadUserPrefsFromFile requires a parameter");
@@ -942,36 +976,37 @@ Preferences::SavePrefFileBlocking()
nsresult
Preferences::SavePrefFileAsynchronous()
{
return SavePrefFileInternal(nullptr, SaveMethod::Asynchronous);
}
NS_IMETHODIMP
-Preferences::SavePrefFile(nsIFile *aFile)
+Preferences::SavePrefFile(nsIFile* aFile)
{
// This is the method accessible from service API. Make it off
// main thread.
return SavePrefFileInternal(aFile, SaveMethod::Asynchronous);
}
static nsresult
-ReadExtensionPrefs(nsIFile *aFile)
+ReadExtensionPrefs(nsIFile* aFile)
{
nsresult rv;
nsCOMPtr<nsIZipReader> reader = do_CreateInstance(kZipReaderCID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = reader->Open(aFile);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIUTF8StringEnumerator> files;
- rv = reader->FindEntries(nsDependentCString("defaults/preferences/*.(J|j)(S|s)$"),
- getter_AddRefs(files));
+ rv = reader->FindEntries(
+ nsDependentCString("defaults/preferences/*.(J|j)(S|s)$"),
+ getter_AddRefs(files));
NS_ENSURE_SUCCESS(rv, rv);
char buffer[4096];
bool more;
while (NS_SUCCEEDED(rv = files->HasMore(&more)) && more) {
nsAutoCString entry;
rv = files->GetNext(entry);
@@ -1004,17 +1039,17 @@ void
Preferences::SetPreference(const PrefSetting& aPref)
{
pref_SetPref(aPref);
}
void
Preferences::GetPreference(PrefSetting* aPref)
{
- PrefHashEntry *entry = pref_HashTableLookup(aPref->name().get());
+ PrefHashEntry* entry = pref_HashTableLookup(aPref->name().get());
if (!entry)
return;
if (pref_EntryHasAdvisablySizedValues(entry)) {
pref_GetPrefFromEntry(entry, aPref);
}
}
@@ -1024,17 +1059,17 @@ Preferences::GetPreferences(InfallibleTA
aPrefs->SetCapacity(gHashTable->Capacity());
for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
auto entry = static_cast<PrefHashEntry*>(iter.Get());
if (!pref_EntryHasAdvisablySizedValues(entry)) {
continue;
}
- dom::PrefSetting *pref = aPrefs->AppendElement();
+ dom::PrefSetting* pref = aPrefs->AppendElement();
pref_GetPrefFromEntry(entry, pref);
}
}
#ifdef DEBUG
void
Preferences::SetInitPhase(pref_initPhase phase)
{
@@ -1044,17 +1079,17 @@ Preferences::SetInitPhase(pref_initPhase
pref_initPhase
Preferences::InitPhase()
{
return pref_GetInitPhase();
}
#endif
NS_IMETHODIMP
-Preferences::GetBranch(const char *aPrefRoot, nsIPrefBranch **_retval)
+Preferences::GetBranch(const char* aPrefRoot, nsIPrefBranch** _retval)
{
nsresult rv;
if ((nullptr != aPrefRoot) && (*aPrefRoot != '\0')) {
// TODO: - cache this stuff and allow consumers to share branches (hold weak references I think)
RefPtr<nsPrefBranch> prefBranch = new nsPrefBranch(aPrefRoot, false);
prefBranch.forget(_retval);
rv = NS_OK;
@@ -1063,17 +1098,17 @@ Preferences::GetBranch(const char *aPref
nsCOMPtr<nsIPrefBranch> root(sRootBranch);
root.forget(_retval);
rv = NS_OK;
}
return rv;
}
NS_IMETHODIMP
-Preferences::GetDefaultBranch(const char *aPrefRoot, nsIPrefBranch **_retval)
+Preferences::GetDefaultBranch(const char* aPrefRoot, nsIPrefBranch** _retval)
{
if (!aPrefRoot || !aPrefRoot[0]) {
nsCOMPtr<nsIPrefBranch> root(sDefaultRootBranch);
root.forget(_retval);
return NS_OK;
}
// TODO: - cache this stuff and allow consumers to share branches (hold weak references I think)
@@ -1081,82 +1116,85 @@ Preferences::GetDefaultBranch(const char
if (!prefBranch)
return NS_ERROR_OUT_OF_MEMORY;
prefBranch.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
-Preferences::GetDirty(bool *_retval) {
+Preferences::GetDirty(bool* _retval)
+{
*_retval = mDirty;
return NS_OK;
}
nsresult
-Preferences::NotifyServiceObservers(const char *aTopic)
+Preferences::NotifyServiceObservers(const char* aTopic)
{
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
if (!observerService)
return NS_ERROR_FAILURE;
- nsISupports *subject = (nsISupports *)((nsIPrefService *)this);
+ nsISupports* subject = (nsISupports*)((nsIPrefService*)this);
observerService->NotifyObservers(subject, aTopic, nullptr);
return NS_OK;
}
already_AddRefed<nsIFile>
Preferences::ReadSavedPrefs()
{
nsCOMPtr<nsIFile> file;
- nsresult rv = NS_GetSpecialDirectory(NS_APP_PREFS_50_FILE,
- getter_AddRefs(file));
+ nsresult rv =
+ NS_GetSpecialDirectory(NS_APP_PREFS_50_FILE, getter_AddRefs(file));
if (NS_WARN_IF(NS_FAILED(rv))) {
return nullptr;
}
rv = openPrefFile(file);
if (rv == NS_ERROR_FILE_NOT_FOUND) {
// this is a normal case for new users
- Telemetry::ScalarSet(Telemetry::ScalarID::PREFERENCES_CREATED_NEW_USER_PREFS_FILE, true);
+ Telemetry::ScalarSet(
+ Telemetry::ScalarID::PREFERENCES_CREATED_NEW_USER_PREFS_FILE, true);
rv = NS_OK;
} else if (NS_FAILED(rv)) {
// Save a backup copy of the current (invalid) prefs file, since all prefs
// from the error line to the end of the file will be lost (bug 361102).
// TODO we should notify the user about it (bug 523725).
- Telemetry::ScalarSet(Telemetry::ScalarID::PREFERENCES_PREFS_FILE_WAS_INVALID, true);
+ Telemetry::ScalarSet(
+ Telemetry::ScalarID::PREFERENCES_PREFS_FILE_WAS_INVALID, true);
MakeBackupPrefFile(file);
}
return file.forget();
}
void
Preferences::ReadUserOverridePrefs()
{
nsCOMPtr<nsIFile> aFile;
- nsresult rv = NS_GetSpecialDirectory(NS_APP_PREFS_50_DIR,
- getter_AddRefs(aFile));
+ nsresult rv =
+ NS_GetSpecialDirectory(NS_APP_PREFS_50_DIR, getter_AddRefs(aFile));
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
aFile->AppendNative(NS_LITERAL_CSTRING("user.js"));
rv = openPrefFile(aFile);
if (rv != NS_ERROR_FILE_NOT_FOUND) {
// If the file exists and was at least partially read, record that
// in telemetry as it may be a sign of pref injection.
Telemetry::ScalarSet(Telemetry::ScalarID::PREFERENCES_READ_USER_JS, true);
}
}
nsresult
-Preferences::MakeBackupPrefFile(nsIFile *aFile)
+Preferences::MakeBackupPrefFile(nsIFile* aFile)
{
// Example: this copies "prefs.js" to "Invalidprefs.js" in the same directory.
// "Invalidprefs.js" is removed if it exists, prior to making the copy.
nsAutoString newFilename;
nsresult rv = aFile->GetLeafName(newFilename);
NS_ENSURE_SUCCESS(rv, rv);
newFilename.InsertLiteral(u"Invalid", 0);
nsCOMPtr<nsIFile> newFile;
@@ -1171,17 +1209,17 @@ Preferences::MakeBackupPrefFile(nsIFile
NS_ENSURE_SUCCESS(rv, rv);
}
rv = aFile->CopyTo(nullptr, newFilename);
NS_ENSURE_SUCCESS(rv, rv);
return rv;
}
nsresult
-Preferences::SavePrefFileInternal(nsIFile *aFile, SaveMethod aSaveMethod)
+Preferences::SavePrefFileInternal(nsIFile* aFile, SaveMethod aSaveMethod)
{
if (MOZ_UNLIKELY(!XRE_IsParentProcess())) {
NS_ERROR("must save pref file from parent process");
return NS_ERROR_NOT_AVAILABLE;
}
// We allow different behavior here when aFile argument is not null,
// but it happens to be the same as the current file. It is not
@@ -1263,42 +1301,40 @@ Preferences::WritePrefFile(nsIFile* aFil
SyncRunnable::DispatchToThread(target, new PWRunnable(aFile), true);
}
return rv;
}
}
// If we can't get the thread for writing, for whatever reason, do the
// main thread write after making some noise:
- MOZ_ASSERT(false,"failed to get the target thread for OMT pref write");
+ MOZ_ASSERT(false, "failed to get the target thread for OMT pref write");
}
// This will do a main thread write. It is safe to do it this way
// as AllowOffMainThreadSave() returns a consistent value for the
// lifetime of the parent process.
PrefSaveData prefsData = pref_savePrefs(gHashTable);
return PreferencesWriter::Write(aFile, prefsData);
}
-static nsresult openPrefFile(nsIFile* aFile)
+static nsresult
+openPrefFile(nsIFile* aFile)
{
PrefParseState ps;
PREF_InitParseState(&ps, PREF_ReaderCallback, ReportToConsole, nullptr);
- auto cleanup = MakeScopeExit([&] () {
- PREF_FinalizeParseState(&ps);
- });
+ auto cleanup = MakeScopeExit([&]() { PREF_FinalizeParseState(&ps); });
nsCString data;
MOZ_TRY_VAR(data, URLPreloader::ReadFile(aFile));
if (!PREF_ParseBuf(&ps, data.get(), data.Length())) {
return NS_ERROR_FILE_CORRUPTED;
}
return NS_OK;
-
}
/*
* some stuff that gets called from Pref_Init()
*/
static int
pref_CompareFileNames(nsIFile* aFile1, nsIFile* aFile2, void* /*unused*/)
@@ -1311,29 +1347,32 @@ pref_CompareFileNames(nsIFile* aFile1, n
}
/**
* Load default pref files from a directory. The files in the
* directory are sorted reverse-alphabetically; a set of "special file
* names" may be specified which are loaded after all the others.
*/
static nsresult
-pref_LoadPrefsInDir(nsIFile* aDir, char const *const *aSpecialFiles, uint32_t aSpecialFilesCount)
+pref_LoadPrefsInDir(nsIFile* aDir,
+ char const* const* aSpecialFiles,
+ uint32_t aSpecialFilesCount)
{
nsresult rv, rv2;
bool hasMoreElements;
nsCOMPtr<nsISimpleEnumerator> dirIterator;
// this may fail in some normal cases, such as embedders who do not use a GRE
rv = aDir->GetDirectoryEntries(getter_AddRefs(dirIterator));
if (NS_FAILED(rv)) {
// If the directory doesn't exist, then we have no reason to complain. We
// loaded everything (and nothing) successfully.
- if (rv == NS_ERROR_FILE_NOT_FOUND || rv == NS_ERROR_FILE_TARGET_DOES_NOT_EXIST)
+ if (rv == NS_ERROR_FILE_NOT_FOUND ||
+ rv == NS_ERROR_FILE_TARGET_DOES_NOT_EXIST)
rv = NS_OK;
return rv;
}
rv = dirIterator->HasMoreElements(&hasMoreElements);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMArray<nsIFile> prefFiles(INITIAL_PREF_FILES);
@@ -1346,20 +1385,23 @@ pref_LoadPrefsInDir(nsIFile* aDir, char
nsCOMPtr<nsISupports> supports;
rv = dirIterator->GetNext(getter_AddRefs(supports));
prefFile = do_QueryInterface(supports);
if (NS_FAILED(rv)) {
break;
}
prefFile->GetNativeLeafName(leafName);
- NS_ASSERTION(!leafName.IsEmpty(), "Failure in default prefs: directory enumerator returned empty file?");
+ NS_ASSERTION(
+ !leafName.IsEmpty(),
+ "Failure in default prefs: directory enumerator returned empty file?");
// Skip non-js files
- if (StringEndsWith(leafName, NS_LITERAL_CSTRING(".js"),
+ if (StringEndsWith(leafName,
+ NS_LITERAL_CSTRING(".js"),
nsCaseInsensitiveCStringComparator())) {
bool shouldParse = true;
// separate out special files
for (uint32_t i = 0; i < aSpecialFilesCount; ++i) {
if (leafName.Equals(nsDependentCString(aSpecialFiles[i]))) {
shouldParse = false;
// special files should be process in order; we put them into
// the array by index; this can make the array sparse
@@ -1406,27 +1448,27 @@ pref_LoadPrefsInDir(nsIFile* aDir, char
rv = rv2;
}
}
}
return rv;
}
-static nsresult pref_LoadPrefsInDirList(const char *listId)
+static nsresult
+pref_LoadPrefsInDirList(const char* listId)
{
nsresult rv;
- nsCOMPtr<nsIProperties> dirSvc(do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv));
+ nsCOMPtr<nsIProperties> dirSvc(
+ do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv));
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsISimpleEnumerator> list;
- dirSvc->Get(listId,
- NS_GET_IID(nsISimpleEnumerator),
- getter_AddRefs(list));
+ dirSvc->Get(listId, NS_GET_IID(nsISimpleEnumerator), getter_AddRefs(list));
if (!list)
return NS_OK;
bool hasMore;
while (NS_SUCCEEDED(list->HasMoreElements(&hasMore)) && hasMore) {
nsCOMPtr<nsISupports> elem;
list->GetNext(getter_AddRefs(elem));
if (!elem)
@@ -1443,20 +1485,22 @@ static nsresult pref_LoadPrefsInDirList(
if (Substring(leaf, leaf.Length() - 4).EqualsLiteral(".xpi"))
ReadExtensionPrefs(path);
else
pref_LoadPrefsInDir(path, nullptr, 0);
}
return NS_OK;
}
-static nsresult pref_ReadPrefFromJar(nsZipArchive* jarReader, const char *name)
+static nsresult
+pref_ReadPrefFromJar(nsZipArchive* jarReader, const char* name)
{
nsCString manifest;
- MOZ_TRY_VAR(manifest, URLPreloader::ReadZip(jarReader, nsDependentCString(name)));
+ MOZ_TRY_VAR(manifest,
+ URLPreloader::ReadZip(jarReader, nsDependentCString(name)));
PrefParseState ps;
PREF_InitParseState(&ps, PREF_ReaderCallback, ReportToConsole, nullptr);
PREF_ParseBuf(&ps, manifest.get(), manifest.Length());
PREF_FinalizeParseState(&ps);
return NS_OK;
}
@@ -1488,147 +1532,155 @@ pref_InitInitialObjects()
// - $app/defaults/preferences/*.js
// and in non omni.jar case:
// - $app/defaults/preferences/*.js
// When $app == $gre, we additionally load, in omni.jar case:
// - jar:$gre/omni.jar!/defaults/preferences/*.js
// Thus, in omni.jar case, we always load app-specific default preferences
// from omni.jar, whether or not $app == $gre.
- nsZipFind *findPtr;
+ nsZipFind* findPtr;
nsAutoPtr<nsZipFind> find;
nsTArray<nsCString> prefEntries;
- const char *entryName;
+ const char* entryName;
uint16_t entryNameLen;
- RefPtr<nsZipArchive> jarReader = mozilla::Omnijar::GetReader(mozilla::Omnijar::GRE);
+ RefPtr<nsZipArchive> jarReader =
+ mozilla::Omnijar::GetReader(mozilla::Omnijar::GRE);
if (jarReader) {
// Load jar:$gre/omni.jar!/greprefs.js
rv = pref_ReadPrefFromJar(jarReader, "greprefs.js");
NS_ENSURE_SUCCESS(rv, Err("pref_ReadPrefFromJar() failed"));
// Load jar:$gre/omni.jar!/defaults/pref/*.js
rv = jarReader->FindInit("defaults/pref/*.js$", &findPtr);
NS_ENSURE_SUCCESS(rv, Err("jarReader->FindInit() failed"));
find = findPtr;
while (NS_SUCCEEDED(find->FindNext(&entryName, &entryNameLen))) {
prefEntries.AppendElement(Substring(entryName, entryNameLen));
}
prefEntries.Sort();
- for (uint32_t i = prefEntries.Length(); i--; ) {
+ for (uint32_t i = prefEntries.Length(); i--;) {
rv = pref_ReadPrefFromJar(jarReader, prefEntries[i].get());
if (NS_FAILED(rv))
NS_WARNING("Error parsing preferences.");
}
} else {
// Load $gre/greprefs.js
nsCOMPtr<nsIFile> greprefsFile;
rv = NS_GetSpecialDirectory(NS_GRE_DIR, getter_AddRefs(greprefsFile));
NS_ENSURE_SUCCESS(rv, Err("NS_GetSpecialDirectory(NS_GRE_DIR) failed"));
rv = greprefsFile->AppendNative(NS_LITERAL_CSTRING("greprefs.js"));
NS_ENSURE_SUCCESS(rv, Err("greprefsFile->AppendNative() failed"));
rv = openPrefFile(greprefsFile);
if (NS_FAILED(rv))
- NS_WARNING("Error parsing GRE default preferences. Is this an old-style embedding app?");
+ NS_WARNING("Error parsing GRE default preferences. Is this an old-style "
+ "embedding app?");
}
// Load $gre/defaults/pref/*.js
nsCOMPtr<nsIFile> defaultPrefDir;
- rv = NS_GetSpecialDirectory(NS_APP_PREF_DEFAULTS_50_DIR, getter_AddRefs(defaultPrefDir));
+ rv = NS_GetSpecialDirectory(NS_APP_PREF_DEFAULTS_50_DIR,
+ getter_AddRefs(defaultPrefDir));
NS_ENSURE_SUCCESS(
rv, Err("NS_GetSpecialDirectory(NS_APP_PREF_DEFAULTS_50_DIR) failed"));
/* these pref file names should not be used: we process them after all other application pref files for backwards compatibility */
static const char* specialFiles[] = {
#if defined(XP_MACOSX)
"macprefs.js"
#elif defined(XP_WIN)
"winpref.js"
#elif defined(XP_UNIX)
"unix.js"
#if defined(_AIX)
- , "aix.js"
+ ,
+ "aix.js"
#endif
#elif defined(XP_BEOS)
"beos.js"
#endif
};
- rv = pref_LoadPrefsInDir(defaultPrefDir, specialFiles, ArrayLength(specialFiles));
+ rv = pref_LoadPrefsInDir(
+ defaultPrefDir, specialFiles, ArrayLength(specialFiles));
if (NS_FAILED(rv))
NS_WARNING("Error parsing application default preferences.");
// Load jar:$app/omni.jar!/defaults/preferences/*.js
// or jar:$gre/omni.jar!/defaults/preferences/*.js.
- RefPtr<nsZipArchive> appJarReader = mozilla::Omnijar::GetReader(mozilla::Omnijar::APP);
+ RefPtr<nsZipArchive> appJarReader =
+ mozilla::Omnijar::GetReader(mozilla::Omnijar::APP);
// GetReader(mozilla::Omnijar::APP) returns null when $app == $gre, in which
// case we look for app-specific default preferences in $gre.
if (!appJarReader)
appJarReader = mozilla::Omnijar::GetReader(mozilla::Omnijar::GRE);
if (appJarReader) {
rv = appJarReader->FindInit("defaults/preferences/*.js$", &findPtr);
NS_ENSURE_SUCCESS(rv, Err("appJarReader->FindInit() failed"));
find = findPtr;
prefEntries.Clear();
while (NS_SUCCEEDED(find->FindNext(&entryName, &entryNameLen))) {
prefEntries.AppendElement(Substring(entryName, entryNameLen));
}
prefEntries.Sort();
- for (uint32_t i = prefEntries.Length(); i--; ) {
+ for (uint32_t i = prefEntries.Length(); i--;) {
rv = pref_ReadPrefFromJar(appJarReader, prefEntries[i].get());
if (NS_FAILED(rv))
NS_WARNING("Error parsing preferences.");
}
}
rv = pref_LoadPrefsInDirList(NS_APP_PREFS_DEFAULTS_DIR_LIST);
NS_ENSURE_SUCCESS(
rv, Err("pref_LoadPrefsInDirList(NS_APP_PREFS_DEFAULTS_DIR_LIST) failed"));
// Set up the correct default for toolkit.telemetry.enabled.
// If this build has MOZ_TELEMETRY_ON_BY_DEFAULT *or* we're on the beta
// channel, telemetry is on by default, otherwise not. This is necessary
// so that beta users who are testing final release builds don't flipflop
// defaults.
- if (Preferences::GetDefaultType(kTelemetryPref) == nsIPrefBranch::PREF_INVALID) {
+ if (Preferences::GetDefaultType(kTelemetryPref) ==
+ nsIPrefBranch::PREF_INVALID) {
bool prerelease = false;
#ifdef MOZ_TELEMETRY_ON_BY_DEFAULT
prerelease = true;
#else
nsAutoCString prefValue;
Preferences::GetDefaultCString(kChannelPref, prefValue);
if (prefValue.EqualsLiteral("beta")) {
prerelease = true;
}
#endif
PREF_SetBoolPref(kTelemetryPref, prerelease, true);
}
NS_CreateServicesFromCategory(NS_PREFSERVICE_APPDEFAULTS_TOPIC_ID,
- nullptr, NS_PREFSERVICE_APPDEFAULTS_TOPIC_ID);
+ nullptr,
+ NS_PREFSERVICE_APPDEFAULTS_TOPIC_ID);
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
NS_ENSURE_SUCCESS(rv, Err("GetObserverService() failed (2)"));
- observerService->NotifyObservers(nullptr, NS_PREFSERVICE_APPDEFAULTS_TOPIC_ID, nullptr);
+ observerService->NotifyObservers(
+ nullptr, NS_PREFSERVICE_APPDEFAULTS_TOPIC_ID, nullptr);
rv = pref_LoadPrefsInDirList(NS_EXT_PREFS_DEFAULTS_DIR_LIST);
NS_ENSURE_SUCCESS(
rv, Err("pref_LoadPrefsInDirList(NS_EXT_PREFS_DEFAULTS_DIR_LIST) failed"));
return Ok();
}
-
/******************************************************************************
*
* static utilities
*
******************************************************************************/
// static
nsresult
@@ -1702,46 +1754,45 @@ Preferences::GetLocalizedCString(const c
}
// static
nsresult
Preferences::GetLocalizedString(const char* aPref, nsAString& aResult)
{
NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
nsCOMPtr<nsIPrefLocalizedString> prefLocalString;
- nsresult rv = sRootBranch->GetComplexValue(aPref,
- NS_GET_IID(nsIPrefLocalizedString),
- getter_AddRefs(prefLocalString));
+ nsresult rv = sRootBranch->GetComplexValue(
+ aPref, NS_GET_IID(nsIPrefLocalizedString), getter_AddRefs(prefLocalString));
if (NS_SUCCEEDED(rv)) {
NS_ASSERTION(prefLocalString, "Succeeded but the result is NULL");
prefLocalString->GetData(getter_Copies(aResult));
}
return rv;
}
// static
nsresult
-Preferences::GetComplex(const char* aPref, const nsIID &aType, void** aResult)
+Preferences::GetComplex(const char* aPref, const nsIID& aType, void** aResult)
{
NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
return sRootBranch->GetComplexValue(aPref, aType, aResult);
}
// static
nsresult
Preferences::SetCString(const char* aPref, const char* aValue)
{
ENSURE_MAIN_PROCESS("Cannot SetCString from content process:", aPref);
NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
return PREF_SetCharPref(aPref, aValue, false);
}
// static
nsresult
-Preferences::SetCString(const char* aPref, const nsACString &aValue)
+Preferences::SetCString(const char* aPref, const nsACString& aValue)
{
ENSURE_MAIN_PROCESS("Cannot SetCString from content process:", aPref);
NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
return PREF_SetCharPref(aPref, PromiseFlatCString(aValue).get(), false);
}
// static
nsresult
@@ -1749,17 +1800,17 @@ Preferences::SetString(const char* aPref
{
ENSURE_MAIN_PROCESS("Cannot SetString from content process:", aPref);
NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
return PREF_SetCharPref(aPref, NS_ConvertUTF16toUTF8(aValue).get(), false);
}
// static
nsresult
-Preferences::SetString(const char* aPref, const nsAString &aValue)
+Preferences::SetString(const char* aPref, const nsAString& aValue)
{
ENSURE_MAIN_PROCESS("Cannot SetString from content process:", aPref);
NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
return PREF_SetCharPref(aPref, NS_ConvertUTF16toUTF8(aValue).get(), false);
}
// static
nsresult
@@ -1783,17 +1834,18 @@ Preferences::SetInt(const char* aPref, i
nsresult
Preferences::SetFloat(const char* aPref, float aValue)
{
return SetCString(aPref, nsPrintfCString("%f", aValue).get());
}
// static
nsresult
-Preferences::SetComplex(const char* aPref, const nsIID &aType,
+Preferences::SetComplex(const char* aPref,
+ const nsIID& aType,
nsISupports* aValue)
{
NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
return sRootBranch->SetComplexValue(aPref, aType, aValue);
}
// static
nsresult
@@ -1813,122 +1865,120 @@ Preferences::HasUserValue(const char* aP
}
// static
int32_t
Preferences::GetType(const char* aPref)
{
NS_ENSURE_TRUE(InitStaticMembers(), nsIPrefBranch::PREF_INVALID);
int32_t result;
- return NS_SUCCEEDED(sRootBranch->GetPrefType(aPref, &result)) ?
- result : nsIPrefBranch::PREF_INVALID;
+ return NS_SUCCEEDED(sRootBranch->GetPrefType(aPref, &result))
+ ? result
+ : nsIPrefBranch::PREF_INVALID;
}
// static
nsresult
-Preferences::AddStrongObserver(nsIObserver* aObserver,
- const char* aPref)
+Preferences::AddStrongObserver(nsIObserver* aObserver, const char* aPref)
{
MOZ_ASSERT(aObserver);
NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
return sRootBranch->AddObserver(aPref, aObserver, false);
}
// static
nsresult
-Preferences::AddWeakObserver(nsIObserver* aObserver,
- const char* aPref)
+Preferences::AddWeakObserver(nsIObserver* aObserver, const char* aPref)
{
MOZ_ASSERT(aObserver);
NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
return sRootBranch->AddObserver(aPref, aObserver, true);
}
// static
nsresult
-Preferences::RemoveObserver(nsIObserver* aObserver,
- const char* aPref)
+Preferences::RemoveObserver(nsIObserver* aObserver, const char* aPref)
{
MOZ_ASSERT(aObserver);
if (!sPreferences && sShutdown) {
return NS_OK; // Observers have been released automatically.
}
NS_ENSURE_TRUE(sPreferences, NS_ERROR_NOT_AVAILABLE);
return sRootBranch->RemoveObserver(aPref, aObserver);
}
// static
nsresult
-Preferences::AddStrongObservers(nsIObserver* aObserver,
- const char** aPrefs)
+Preferences::AddStrongObservers(nsIObserver* aObserver, const char** aPrefs)
{
MOZ_ASSERT(aObserver);
for (uint32_t i = 0; aPrefs[i]; i++) {
nsresult rv = AddStrongObserver(aObserver, aPrefs[i]);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
// static
nsresult
-Preferences::AddWeakObservers(nsIObserver* aObserver,
- const char** aPrefs)
+Preferences::AddWeakObservers(nsIObserver* aObserver, const char** aPrefs)
{
MOZ_ASSERT(aObserver);
for (uint32_t i = 0; aPrefs[i]; i++) {
nsresult rv = AddWeakObserver(aObserver, aPrefs[i]);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
// static
nsresult
-Preferences::RemoveObservers(nsIObserver* aObserver,
- const char** aPrefs)
+Preferences::RemoveObservers(nsIObserver* aObserver, const char** aPrefs)
{
MOZ_ASSERT(aObserver);
if (!sPreferences && sShutdown) {
return NS_OK; // Observers have been released automatically.
}
NS_ENSURE_TRUE(sPreferences, NS_ERROR_NOT_AVAILABLE);
for (uint32_t i = 0; aPrefs[i]; i++) {
nsresult rv = RemoveObserver(aObserver, aPrefs[i]);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
-static void NotifyObserver(const char* aPref, void* aClosure)
+static void
+NotifyObserver(const char* aPref, void* aClosure)
{
nsCOMPtr<nsIObserver> observer = static_cast<nsIObserver*>(aClosure);
- observer->Observe(nullptr, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID,
+ observer->Observe(nullptr,
+ NS_PREFBRANCH_PREFCHANGE_TOPIC_ID,
NS_ConvertASCIItoUTF16(aPref).get());
}
-static void RegisterPriorityCallback(PrefChangedFunc aCallback,
- const char* aPref,
- void* aClosure)
+static void
+RegisterPriorityCallback(PrefChangedFunc aCallback,
+ const char* aPref,
+ void* aClosure)
{
MOZ_ASSERT(Preferences::IsServiceAvailable());
ValueObserverHashKey hashKey(aPref, aCallback, Preferences::ExactMatch);
RefPtr<ValueObserver> observer;
gObserverTable->Get(&hashKey, getter_AddRefs(observer));
if (observer) {
observer->AppendClosure(aClosure);
return;
}
observer = new ValueObserver(aPref, aCallback, Preferences::ExactMatch);
observer->AppendClosure(aClosure);
- PREF_RegisterPriorityCallback(aPref, NotifyObserver,
- static_cast<nsIObserver*>(observer));
+ PREF_RegisterPriorityCallback(
+ aPref, NotifyObserver, static_cast<nsIObserver*>(observer));
gObserverTable->Put(observer, observer);
}
// static
nsresult
Preferences::RegisterCallback(PrefChangedFunc aCallback,
const char* aPref,
void* aClosure,
@@ -1996,17 +2046,18 @@ Preferences::UnregisterCallback(PrefChan
}
return NS_OK;
}
// We insert cache observers using RegisterPriorityCallback to ensure they
// are called prior to ordinary pref observers. Doing this ensures that
// ordinary observers will never get stale values from cache variables.
-static void BoolVarChanged(const char* aPref, void* aClosure)
+static void
+BoolVarChanged(const char* aPref, void* aClosure)
{
CacheData* cache = static_cast<CacheData*>(aClosure);
*((bool*)cache->cacheLocation) =
Preferences::GetBool(aPref, cache->defaultValueBool);
}
static void
CacheDataAppendElement(CacheData* aData)
@@ -2014,35 +2065,34 @@ CacheDataAppendElement(CacheData* aData)
if (!gCacheData) {
MOZ_CRASH_UNSAFE_PRINTF("!gCacheData: %s", gCacheDataDesc);
}
gCacheData->AppendElement(aData);
}
// static
nsresult
-Preferences::AddBoolVarCache(bool* aCache,
- const char* aPref,
- bool aDefault)
+Preferences::AddBoolVarCache(bool* aCache, const char* aPref, bool aDefault)
{
WATCHING_PREF_RAII();
NS_ASSERTION(aCache, "aCache must not be NULL");
#ifdef DEBUG
AssertNotAlreadyCached("bool", aPref, aCache);
#endif
*aCache = GetBool(aPref, aDefault);
CacheData* data = new CacheData();
data->cacheLocation = aCache;
data->defaultValueBool = aDefault;
CacheDataAppendElement(data);
RegisterPriorityCallback(BoolVarChanged, aPref, data);
return NS_OK;
}
-static void IntVarChanged(const char* aPref, void* aClosure)
+static void
+IntVarChanged(const char* aPref, void* aClosure)
{
CacheData* cache = static_cast<CacheData*>(aClosure);
*((int32_t*)cache->cacheLocation) =
Preferences::GetInt(aPref, cache->defaultValueInt);
}
// static
nsresult
@@ -2059,17 +2109,18 @@ Preferences::AddIntVarCache(int32_t* aCa
CacheData* data = new CacheData();
data->cacheLocation = aCache;
data->defaultValueInt = aDefault;
CacheDataAppendElement(data);
RegisterPriorityCallback(IntVarChanged, aPref, data);
return NS_OK;
}
-static void UintVarChanged(const char* aPref, void* aClosure)
+static void
+UintVarChanged(const char* aPref, void* aClosure)
{
CacheData* cache = static_cast<CacheData*>(aClosure);
*((uint32_t*)cache->cacheLocation) =
Preferences::GetUint(aPref, cache->defaultValueUint);
}
// static
nsresult
@@ -2086,25 +2137,26 @@ Preferences::AddUintVarCache(uint32_t* a
CacheData* data = new CacheData();
data->cacheLocation = aCache;
data->defaultValueUint = aDefault;
CacheDataAppendElement(data);
RegisterPriorityCallback(UintVarChanged, aPref, data);
return NS_OK;
}
-template <MemoryOrdering Order>
-static void AtomicUintVarChanged(const char* aPref, void* aClosure)
+template<MemoryOrdering Order>
+static void
+AtomicUintVarChanged(const char* aPref, void* aClosure)
{
CacheData* cache = static_cast<CacheData*>(aClosure);
*((Atomic<uint32_t, Order>*)cache->cacheLocation) =
Preferences::GetUint(aPref, cache->defaultValueUint);
}
-template <MemoryOrdering Order>
+template<MemoryOrdering Order>
// static
nsresult
Preferences::AddAtomicUintVarCache(Atomic<uint32_t, Order>* aCache,
const char* aPref,
uint32_t aDefault)
{
WATCHING_PREF_RAII();
NS_ASSERTION(aCache, "aCache must not be NULL");
@@ -2118,32 +2170,32 @@ Preferences::AddAtomicUintVarCache(Atomi
CacheDataAppendElement(data);
RegisterPriorityCallback(AtomicUintVarChanged<Order>, aPref, data);
return NS_OK;
}
// Since the definition of this template function is not in a header file,
// we need to explicitly specify the instantiations that are required.
// Currently only the order=Relaxed variant is needed.
-template
-nsresult Preferences::AddAtomicUintVarCache(Atomic<uint32_t,Relaxed>*,
- const char*, uint32_t);
+template nsresult
+Preferences::AddAtomicUintVarCache(Atomic<uint32_t, Relaxed>*,
+ const char*,
+ uint32_t);
-static void FloatVarChanged(const char* aPref, void* aClosure)
+static void
+FloatVarChanged(const char* aPref, void* aClosure)
{
CacheData* cache = static_cast<CacheData*>(aClosure);
*((float*)cache->cacheLocation) =
Preferences::GetFloat(aPref, cache->defaultValueFloat);
}
// static
nsresult
-Preferences::AddFloatVarCache(float* aCache,
- const char* aPref,
- float aDefault)
+Preferences::AddFloatVarCache(float* aCache, const char* aPref, float aDefault)
{
WATCHING_PREF_RAII();
NS_ASSERTION(aCache, "aCache must not be NULL");
#ifdef DEBUG
AssertNotAlreadyCached("float", aPref, aCache);
#endif
*aCache = Preferences::GetFloat(aPref, aDefault);
CacheData* data = new CacheData();
@@ -2195,59 +2247,57 @@ Preferences::GetDefaultString(const char
if (NS_SUCCEEDED(rv)) {
CopyUTF8toUTF16(result, aResult);
}
return rv;
}
// static
nsresult
-Preferences::GetDefaultLocalizedCString(const char* aPref,
- nsACString& aResult)
+Preferences::GetDefaultLocalizedCString(const char* aPref, nsACString& aResult)
{
nsAutoString result;
nsresult rv = GetDefaultLocalizedString(aPref, result);
if (NS_SUCCEEDED(rv)) {
CopyUTF16toUTF8(result, aResult);
}
return rv;
}
// static
nsresult
-Preferences::GetDefaultLocalizedString(const char* aPref,
- nsAString& aResult)
+Preferences::GetDefaultLocalizedString(const char* aPref, nsAString& aResult)
{
NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
nsCOMPtr<nsIPrefLocalizedString> prefLocalString;
- nsresult rv =
- sDefaultRootBranch->GetComplexValue(aPref,
- NS_GET_IID(nsIPrefLocalizedString),
- getter_AddRefs(prefLocalString));
+ nsresult rv = sDefaultRootBranch->GetComplexValue(
+ aPref, NS_GET_IID(nsIPrefLocalizedString), getter_AddRefs(prefLocalString));
if (NS_SUCCEEDED(rv)) {
NS_ASSERTION(prefLocalString, "Succeeded but the result is NULL");
prefLocalString->GetData(getter_Copies(aResult));
}
return rv;
}
// static
nsresult
-Preferences::GetDefaultComplex(const char* aPref, const nsIID &aType,
+Preferences::GetDefaultComplex(const char* aPref,
+ const nsIID& aType,
void** aResult)
{
NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
return sDefaultRootBranch->GetComplexValue(aPref, aType, aResult);
}
// static
int32_t
Preferences::GetDefaultType(const char* aPref)
{
NS_ENSURE_TRUE(InitStaticMembers(), nsIPrefBranch::PREF_INVALID);
int32_t result;
- return NS_SUCCEEDED(sDefaultRootBranch->GetPrefType(aPref, &result)) ?
- result : nsIPrefBranch::PREF_INVALID;
+ return NS_SUCCEEDED(sDefaultRootBranch->GetPrefType(aPref, &result))
+ ? result
+ : nsIPrefBranch::PREF_INVALID;
}
} // namespace mozilla
#undef ENSURE_MAIN_PROCESS