diff options
Diffstat (limited to 'modules/libpref/Preferences.cpp')
| -rw-r--r-- | modules/libpref/Preferences.cpp | 2023 |
1 files changed, 2023 insertions, 0 deletions
diff --git a/modules/libpref/Preferences.cpp b/modules/libpref/Preferences.cpp new file mode 100644 index 000000000..f36819236 --- /dev/null +++ b/modules/libpref/Preferences.cpp @@ -0,0 +1,2023 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/MemoryReporting.h" +#include "mozilla/dom/ContentChild.h" + +#include "mozilla/ArrayUtils.h" +#include "mozilla/Attributes.h" +#include "mozilla/HashFunctions.h" +#include "mozilla/UniquePtrExtensions.h" + +#include "nsXULAppAPI.h" + +#include "mozilla/Preferences.h" +#include "nsAppDirectoryServiceDefs.h" +#include "nsDataHashtable.h" +#include "nsDirectoryServiceDefs.h" +#include "nsICategoryManager.h" +#include "nsCategoryManagerUtils.h" +#include "nsNetUtil.h" +#include "nsIFile.h" +#include "nsIInputStream.h" +#include "nsIObserverService.h" +#include "nsIOutputStream.h" +#include "nsISafeOutputStream.h" +#include "nsISimpleEnumerator.h" +#include "nsIStringEnumerator.h" +#include "nsIZipReader.h" +#include "nsPrefBranch.h" +#include "nsXPIDLString.h" +#include "nsCRT.h" +#include "nsCOMArray.h" +#include "nsXPCOMCID.h" +#include "nsAutoPtr.h" +#include "nsPrintfCString.h" + +#include "nsQuickSort.h" +#include "PLDHashTable.h" + +#include "prefapi.h" +#include "prefread.h" +#include "prefapi_private_data.h" + +#include "mozilla/Omnijar.h" +#include "nsZipArchive.h" + +#include "nsTArray.h" +#include "nsRefPtrHashtable.h" +#include "nsIMemoryReporter.h" +#include "nsThreadUtils.h" + +#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); +#else +#define ENSURE_MAIN_PROCESS(message, pref) \ + if (MOZ_UNLIKELY(!XRE_IsParentProcess())) { \ + return NS_ERROR_NOT_AVAILABLE; \ + } +#endif + +class PrefCallback; + +namespace mozilla { + +// Definitions +#define INITIAL_PREF_FILES 10 +static NS_DEFINE_CID(kZipReaderCID, NS_ZIPREADER_CID); + +void +Preferences::DirtyCallback() +{ + if (gHashTable && sPreferences && !sPreferences->mDirty) { + sPreferences->mDirty = true; + } +} + +// Prototypes +static nsresult openPrefFile(nsIFile* aFile); +static nsresult pref_InitInitialObjects(void); +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"; + +static const char kPrefFileHeader[] = + "# Mozilla User Preferences" + NS_LINEBREAK + NS_LINEBREAK + "/* Do not edit this file." + NS_LINEBREAK + " *" + NS_LINEBREAK + " * If you make changes to this file while the application is running," + NS_LINEBREAK + " * the changes will be overwritten when the application exits." + NS_LINEBREAK + " *" + NS_LINEBREAK + " * To make a manual change to preferences, you can visit the URL about:config" + NS_LINEBREAK + " */" + NS_LINEBREAK + NS_LINEBREAK; + +Preferences* Preferences::sPreferences = nullptr; +nsIPrefBranch* Preferences::sRootBranch = nullptr; +nsIPrefBranch* Preferences::sDefaultRootBranch = nullptr; +bool Preferences::sShutdown = false; + +class ValueObserverHashKey : public PLDHashEntryHdr { +public: + typedef ValueObserverHashKey* KeyType; + typedef const ValueObserverHashKey* KeyTypePointer; + + static const ValueObserverHashKey* KeyToPointer(ValueObserverHashKey *aKey) + { + return 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) { } + + explicit ValueObserverHashKey(const ValueObserverHashKey *aOther) : + mPrefName(aOther->mPrefName), + mCallback(aOther->mCallback), + mMatchKind(aOther->mMatchKind) + { } + + bool KeyEquals(const ValueObserverHashKey *aOther) const + { + return mCallback == aOther->mCallback && + mPrefName == aOther->mPrefName && + mMatchKind == aOther->mMatchKind; + } + + ValueObserverHashKey *GetKey() const + { + return const_cast<ValueObserverHashKey*>(this); + } + + enum { ALLOW_MEMMOVE = true }; + + nsCString mPrefName; + PrefChangedFunc mCallback; + Preferences::MatchKind mMatchKind; +}; + +class ValueObserver final : public nsIObserver, + public ValueObserverHashKey +{ + ~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); + } + + 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) +{ + NS_ASSERTION(!nsCRT::strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID), + "invalid topic"); + NS_ConvertUTF16toUTF8 data(aData); + 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; +} + +struct CacheData { + void* cacheLocation; + union { + bool defaultValueBool; + int32_t defaultValueInt; + uint32_t defaultValueUint; + float defaultValueFloat; + }; +}; + +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) { + if ((*gCacheData)[i]->cacheLocation == aPtr) { + return true; + } + } + } + return false; +} + +static void +AssertNotAlreadyCached(const char* aPrefType, + const char* aPref, + void* aPtr) +{ + if (HaveExistingCacheFor(aPtr)) { + 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"); + } +} +#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); + 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) +{ + 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); + } + if (gCacheData) { + n += gCacheData->ShallowSizeOfIncludingThis(aMallocSizeOf); + for (uint32_t i = 0, count = gCacheData->Length(); i < count; ++i) { + n += aMallocSizeOf((*gCacheData)[i]); + } + } + 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); + } + if (sDefaultRootBranch) { + n += reinterpret_cast<nsPrefBranch*>(sDefaultRootBranch)->SizeOfIncludingThis(aMallocSizeOf); + } + n += pref_SizeOfPrivateData(aMallocSizeOf); + return n; +} + +class PreferenceServiceReporter final : public nsIMemoryReporter +{ + ~PreferenceServiceReporter() {} + +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIMEMORYREPORTER + +protected: + static const uint32_t kSuspectReferentCount = 1000; +}; + +NS_IMPL_ISUPPORTS(PreferenceServiceReporter, nsIMemoryReporter) + +MOZ_DEFINE_MALLOC_SIZE_OF(PreferenceServiceMallocSizeOf) + +NS_IMETHODIMP +PreferenceServiceReporter::CollectReports( + nsIHandleReportCallback* aHandleReport, nsISupports* aData, bool aAnonymize) +{ + 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; + size_t numWeakAlive = 0; + size_t numWeakDead = 0; + nsTArray<nsCString> suspectPreferences; + // Count of the number of referents for each preference. + nsDataHashtable<nsCStringHashKey, uint32_t> prefCounter; + + for (auto iter = rootBranch->mObservers.Iter(); !iter.Done(); iter.Next()) { + nsAutoPtr<PrefCallback>& callback = iter.Data(); + nsPrefBranch* prefBranch = callback->GetPrefBranch(); + const char* pref = prefBranch->getPrefName(callback->GetDomain().get()); + + if (callback->IsWeak()) { + nsCOMPtr<nsIObserver> callbackRef = do_QueryReferent(callback->mWeakRef); + if (callbackRef) { + numWeakAlive++; + } else { + numWeakDead++; + } + } else { + numStrong++; + } + + nsDependentCString prefString(pref); + uint32_t oldCount = 0; + prefCounter.Get(prefString, &oldCount); + uint32_t currentCount = oldCount + 1; + prefCounter.Put(prefString, currentCount); + + // Keep track of preferences that have a suspiciously large number of + // referents (a symptom of a leak). + if (currentCount == kSuspectReferentCount) { + suspectPreferences.AppendElement(prefString); + } + } + + 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()); + + aHandleReport->Callback( + /* process = */ EmptyCString(), + 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, + numStrong, + "The number of strong referents held by the preference service."); + + MOZ_COLLECT_REPORT( + "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, + numWeakDead, + "The number of weak referents held by the preference service that are " + "dead."); + + return NS_OK; +} + +namespace { +class AddPreferencesMemoryReporterRunnable : public Runnable +{ + NS_IMETHOD Run() override + { + return RegisterStrongMemoryReporter(new PreferenceServiceReporter()); + } +}; +} // namespace + +// static +Preferences* +Preferences::GetInstanceForService() +{ + if (sPreferences) { + NS_ADDREF(sPreferences); + return sPreferences; + } + + NS_ENSURE_TRUE(!sShutdown, nullptr); + + sRootBranch = new nsPrefBranch("", false); + NS_ADDREF(sRootBranch); + sDefaultRootBranch = new nsPrefBranch("", true); + NS_ADDREF(sDefaultRootBranch); + + sPreferences = new Preferences(); + NS_ADDREF(sPreferences); + + if (NS_FAILED(sPreferences->Init())) { + // The singleton instance will delete sRootBranch and sDefaultRootBranch. + NS_RELEASE(sPreferences); + return nullptr; + } + + gCacheData = new nsTArray<nsAutoPtr<CacheData> >(); + + 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. + RefPtr<AddPreferencesMemoryReporterRunnable> runnable = + new AddPreferencesMemoryReporterRunnable(); + NS_DispatchToMainThread(runnable); + + NS_ADDREF(sPreferences); + return sPreferences; +} + +// static +bool +Preferences::IsServiceAvailable() +{ + return !!sPreferences; +} + +// static +bool +Preferences::InitStaticMembers() +{ +#ifndef MOZ_B2G + MOZ_ASSERT(NS_IsMainThread()); +#endif + + if (!sShutdown && !sPreferences) { + nsCOMPtr<nsIPrefService> prefService = + do_GetService(NS_PREFSERVICE_CONTRACTID); + } + + return sPreferences != nullptr; +} + +// static +void +Preferences::Shutdown() +{ + if (!sShutdown) { + sShutdown = true; // Don't create the singleton instance after here. + + // Don't set sPreferences to nullptr here. The instance may be grabbed by + // other modules. The utility methods of Preferences should be available + // until the singleton instance actually released. + if (sPreferences) { + sPreferences->Release(); + } + } +} + +//----------------------------------------------------------------------------- + +/* + * Constructor/Destructor + */ + +Preferences::Preferences() + : mDirty(false) +{ +} + +Preferences::~Preferences() +{ + NS_ASSERTION(sPreferences == this, "Isn't this the singleton instance?"); + + delete gObserverTable; + gObserverTable = nullptr; + + delete gCacheData; + gCacheData = nullptr; + + 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(nsIPrefBranch2) + NS_INTERFACE_MAP_ENTRY(nsIPrefBranchInternal) + NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) +NS_INTERFACE_MAP_END + + +/* + * nsIPrefService Implementation + */ + +nsresult +Preferences::Init() +{ + nsresult rv; + + PREF_SetDirtyCallback(&DirtyCallback); + PREF_Init(); + + rv = pref_InitInitialObjects(); + NS_ENSURE_SUCCESS(rv, rv); + + using mozilla::dom::ContentChild; + if (XRE_IsContentProcess()) { + InfallibleTArray<PrefSetting> prefs; + ContentChild::GetSingleton()->SendReadPrefsArray(&prefs); + + // Store the array + for (uint32_t i = 0; i < prefs.Length(); ++i) { + pref_SetPref(prefs[i]); + } + return NS_OK; + } + + nsXPIDLCString lockFileName; + /* + * 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. + */ + + 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"); + + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + if (!observerService) + return NS_ERROR_FAILURE; + + rv = observerService->AddObserver(this, "profile-before-change", true); + + observerService->AddObserver(this, "load-extension-defaults", true); + observerService->AddObserver(this, "suspend_process_notification", true); + + return(rv); +} + +// static +nsresult +Preferences::ResetAndReadUserPrefs() +{ + sPreferences->ResetUserPrefs(); + return sPreferences->ReadUserPrefs(nullptr); +} + +NS_IMETHODIMP +Preferences::Observe(nsISupports *aSubject, const char *aTopic, + const char16_t *someData) +{ + if (XRE_IsContentProcess()) + return NS_ERROR_NOT_AVAILABLE; + + nsresult rv = NS_OK; + + if (!nsCRT::strcmp(aTopic, "profile-before-change")) { + rv = SavePrefFile(nullptr); + } else if (!strcmp(aTopic, "load-extension-defaults")) { + pref_LoadPrefsInDirList(NS_EXT_PREFS_DEFAULTS_DIR_LIST); + } else if (!nsCRT::strcmp(aTopic, "reload-default-prefs")) { + // Reload the default prefs from file. + pref_InitInitialObjects(); + } else if (!nsCRT::strcmp(aTopic, "suspend_process_notification")) { + // 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 = SavePrefFile(nullptr); + } + return rv; +} + + +NS_IMETHODIMP +Preferences::ReadUserPrefs(nsIFile *aFile) +{ + if (XRE_IsContentProcess()) { + NS_ERROR("cannot load prefs from content process"); + return NS_ERROR_NOT_AVAILABLE; + } + + nsresult rv; + + if (nullptr == aFile) { + rv = UseDefaultPrefFile(); + // A user pref file is optional. + // Ignore all errors related to it, so we retain 'rv' value :-| + (void) UseUserPrefFile(); + + // Migrate the old prerelease telemetry pref + if (!Preferences::GetBool(kOldTelemetryPref, true)) { + Preferences::SetBool(kTelemetryPref, false); + Preferences::ClearUser(kOldTelemetryPref); + } + + NotifyServiceObservers(NS_PREFSERVICE_READ_TOPIC_ID); + } else { + rv = ReadAndOwnUserPrefFile(aFile); + } + + return rv; +} + +NS_IMETHODIMP +Preferences::ResetPrefs() +{ + if (XRE_IsContentProcess()) { + NS_ERROR("cannot reset prefs from content process"); + return NS_ERROR_NOT_AVAILABLE; + } + + NotifyServiceObservers(NS_PREFSERVICE_RESET_TOPIC_ID); + PREF_CleanupPrefs(); + + PREF_Init(); + + return pref_InitInitialObjects(); +} + +NS_IMETHODIMP +Preferences::ResetUserPrefs() +{ + if (XRE_IsContentProcess()) { + NS_ERROR("cannot reset user prefs from content process"); + return NS_ERROR_NOT_AVAILABLE; + } + + PREF_ClearAllUserPrefs(); + return NS_OK; +} + +NS_IMETHODIMP +Preferences::SavePrefFile(nsIFile *aFile) +{ + if (XRE_IsContentProcess()) { + NS_ERROR("cannot save pref file from content process"); + return NS_ERROR_NOT_AVAILABLE; + } + + return SavePrefFileInternal(aFile); +} + +static nsresult +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)); + NS_ENSURE_SUCCESS(rv, rv); + + char buffer[4096]; + + bool more; + while (NS_SUCCEEDED(rv = files->HasMore(&more)) && more) { + nsAutoCString entry; + rv = files->GetNext(entry); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIInputStream> stream; + rv = reader->GetInputStream(entry, getter_AddRefs(stream)); + NS_ENSURE_SUCCESS(rv, rv); + + uint64_t avail; + uint32_t read; + + PrefParseState ps; + PREF_InitParseState(&ps, PREF_ReaderCallback, ReportToConsole, nullptr); + while (NS_SUCCEEDED(rv = stream->Available(&avail)) && avail) { + rv = stream->Read(buffer, 4096, &read); + if (NS_FAILED(rv)) { + NS_WARNING("Pref stream read failed"); + break; + } + + PREF_ParseBuf(&ps, buffer, read); + } + PREF_FinalizeParseState(&ps); + } + return rv; +} + +void +Preferences::SetPreference(const PrefSetting& aPref) +{ + pref_SetPref(aPref); +} + +void +Preferences::GetPreference(PrefSetting* aPref) +{ + PrefHashEntry *entry = pref_HashTableLookup(aPref->name().get()); + if (!entry) + return; + + if (pref_EntryHasAdvisablySizedValues(entry)) { + pref_GetPrefFromEntry(entry, aPref); + } +} + +void +Preferences::GetPreferences(InfallibleTArray<PrefSetting>* aPrefs) +{ + 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(); + pref_GetPrefFromEntry(entry, pref); + } +} + +NS_IMETHODIMP +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; + } else { + // special case caching the default root + nsCOMPtr<nsIPrefBranch> root(sRootBranch); + root.forget(_retval); + rv = NS_OK; + } + return rv; +} + +NS_IMETHODIMP +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) + RefPtr<nsPrefBranch> prefBranch = new nsPrefBranch(aPrefRoot, true); + if (!prefBranch) + return NS_ERROR_OUT_OF_MEMORY; + + prefBranch.forget(_retval); + return NS_OK; +} + +NS_IMETHODIMP +Preferences::GetDirty(bool *_retval) { + *_retval = mDirty; + return NS_OK; +} + +nsresult +Preferences::NotifyServiceObservers(const char *aTopic) +{ + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + if (!observerService) + return NS_ERROR_FAILURE; + + nsISupports *subject = (nsISupports *)((nsIPrefService *)this); + observerService->NotifyObservers(subject, aTopic, nullptr); + + return NS_OK; +} + +nsresult +Preferences::UseDefaultPrefFile() +{ + nsCOMPtr<nsIFile> aFile; + nsresult rv = NS_GetSpecialDirectory(NS_APP_PREFS_50_FILE, getter_AddRefs(aFile)); + + if (NS_SUCCEEDED(rv)) { + rv = ReadAndOwnUserPrefFile(aFile); + // Most likely cause of failure here is that the file didn't + // exist, so save a new one. mUserPrefReadFailed will be + // used to catch an error in actually reading the file. + if (NS_FAILED(rv)) { + if (NS_FAILED(SavePrefFileInternal(aFile))) + NS_ERROR("Failed to save new shared pref file"); + else + rv = NS_OK; + } + } + + return rv; +} + +nsresult +Preferences::UseUserPrefFile() +{ + nsresult rv = NS_OK; + nsCOMPtr<nsIFile> aFile; + nsDependentCString prefsDirProp(NS_APP_PREFS_50_DIR); + + rv = NS_GetSpecialDirectory(prefsDirProp.get(), getter_AddRefs(aFile)); + if (NS_SUCCEEDED(rv) && aFile) { + rv = aFile->AppendNative(NS_LITERAL_CSTRING("user.js")); + if (NS_SUCCEEDED(rv)) { + bool exists = false; + aFile->Exists(&exists); + if (exists) { + rv = openPrefFile(aFile); + } else { + rv = NS_ERROR_FILE_NOT_FOUND; + } + } + } + return rv; +} + +nsresult +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.Insert(NS_LITERAL_STRING("Invalid"), 0); + nsCOMPtr<nsIFile> newFile; + rv = aFile->GetParent(getter_AddRefs(newFile)); + NS_ENSURE_SUCCESS(rv, rv); + rv = newFile->Append(newFilename); + NS_ENSURE_SUCCESS(rv, rv); + bool exists = false; + newFile->Exists(&exists); + if (exists) { + rv = newFile->Remove(false); + NS_ENSURE_SUCCESS(rv, rv); + } + rv = aFile->CopyTo(nullptr, newFilename); + NS_ENSURE_SUCCESS(rv, rv); + return rv; +} + +nsresult +Preferences::ReadAndOwnUserPrefFile(nsIFile *aFile) +{ + NS_ENSURE_ARG(aFile); + + if (mCurrentFile == aFile) + return NS_OK; + mCurrentFile = aFile; + + nsresult rv = NS_OK; + bool exists = false; + mCurrentFile->Exists(&exists); + if (exists) { + rv = openPrefFile(mCurrentFile); + 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). + MakeBackupPrefFile(mCurrentFile); + } + } else { + rv = NS_ERROR_FILE_NOT_FOUND; + } + + return rv; +} + +nsresult +Preferences::SavePrefFileInternal(nsIFile *aFile) +{ + if (nullptr == aFile) { + // the mDirty flag tells us if we should write to mCurrentFile + // we only check this flag when the caller wants to write to the default + if (!mDirty) { + return NS_OK; + } + + // It's possible that we never got a prefs file. + nsresult rv = NS_OK; + if (mCurrentFile) + rv = WritePrefFile(mCurrentFile); + + return rv; + } else { + return WritePrefFile(aFile); + } +} + +nsresult +Preferences::WritePrefFile(nsIFile* aFile) +{ + nsCOMPtr<nsIOutputStream> outStreamSink; + nsCOMPtr<nsIOutputStream> outStream; + uint32_t writeAmount; + nsresult rv; + + if (!gHashTable) + return NS_ERROR_NOT_INITIALIZED; + + // execute a "safe" save by saving through a tempfile + rv = NS_NewSafeLocalFileOutputStream(getter_AddRefs(outStreamSink), + aFile, + -1, + 0600); + if (NS_FAILED(rv)) + return rv; + rv = NS_NewBufferedOutputStream(getter_AddRefs(outStream), outStreamSink, 4096); + if (NS_FAILED(rv)) + return rv; + + // get the lines that we're supposed to be writing to the file + uint32_t prefCount; + UniquePtr<char*[]> valueArray = pref_savePrefs(gHashTable, &prefCount); + + /* Sort the preferences to make a readable file on disk */ + NS_QuickSort(valueArray.get(), prefCount, sizeof(char *), + pref_CompareStrings, nullptr); + + // write out the file header + outStream->Write(kPrefFileHeader, sizeof(kPrefFileHeader) - 1, &writeAmount); + + for (uint32_t valueIdx = 0; valueIdx < prefCount; valueIdx++) { + char*& pref = valueArray[valueIdx]; + MOZ_ASSERT(pref); + outStream->Write(pref, strlen(pref), &writeAmount); + outStream->Write(NS_LINEBREAK, NS_LINEBREAK_LEN, &writeAmount); + free(pref); + pref = nullptr; + } + + // tell the safe output stream to overwrite the real prefs file + // (it'll abort if there were any errors during writing) + nsCOMPtr<nsISafeOutputStream> safeStream = do_QueryInterface(outStream); + NS_ASSERTION(safeStream, "expected a safe output stream!"); + if (safeStream) { + rv = safeStream->Finish(); + if (NS_FAILED(rv)) { + NS_WARNING("failed to save prefs file! possible data loss"); + return rv; + } + } + + mDirty = false; + return NS_OK; +} + +static nsresult openPrefFile(nsIFile* aFile) +{ + nsCOMPtr<nsIInputStream> inStr; + + nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(inStr), aFile); + if (NS_FAILED(rv)) + return rv; + + int64_t fileSize64; + rv = aFile->GetFileSize(&fileSize64); + if (NS_FAILED(rv)) + return rv; + NS_ENSURE_TRUE(fileSize64 <= UINT32_MAX, NS_ERROR_FILE_TOO_BIG); + + uint32_t fileSize = (uint32_t)fileSize64; + auto fileBuffer = MakeUniqueFallible<char[]>(fileSize); + if (fileBuffer == nullptr) + return NS_ERROR_OUT_OF_MEMORY; + + PrefParseState ps; + PREF_InitParseState(&ps, PREF_ReaderCallback, ReportToConsole, nullptr); + + // Read is not guaranteed to return a buf the size of fileSize, + // but usually will. + nsresult rv2 = NS_OK; + uint32_t offset = 0; + for (;;) { + uint32_t amtRead = 0; + rv = inStr->Read(fileBuffer.get(), fileSize, &amtRead); + if (NS_FAILED(rv) || amtRead == 0) + break; + if (!PREF_ParseBuf(&ps, fileBuffer.get(), amtRead)) + rv2 = NS_ERROR_FILE_CORRUPTED; + offset += amtRead; + if (offset == fileSize) { + break; + } + } + + PREF_FinalizeParseState(&ps); + + return NS_FAILED(rv) ? rv : rv2; +} + +/* + * some stuff that gets called from Pref_Init() + */ + +static int +pref_CompareFileNames(nsIFile* aFile1, nsIFile* aFile2, void* /*unused*/) +{ + nsAutoCString filename1, filename2; + aFile1->GetNativeLeafName(filename1); + aFile2->GetNativeLeafName(filename2); + + return Compare(filename2, filename1); +} + +/** + * 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) +{ + 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) + rv = NS_OK; + return rv; + } + + rv = dirIterator->HasMoreElements(&hasMoreElements); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMArray<nsIFile> prefFiles(INITIAL_PREF_FILES); + nsCOMArray<nsIFile> specialFiles(aSpecialFilesCount); + nsCOMPtr<nsIFile> prefFile; + + while (hasMoreElements && NS_SUCCEEDED(rv)) { + nsAutoCString leafName; + + 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?"); + + // Skip non-js files + 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 + specialFiles.ReplaceObjectAt(prefFile, i); + } + } + + if (shouldParse) { + prefFiles.AppendObject(prefFile); + } + } + + rv = dirIterator->HasMoreElements(&hasMoreElements); + } + + if (prefFiles.Count() + specialFiles.Count() == 0) { + NS_WARNING("No default pref files found."); + if (NS_SUCCEEDED(rv)) { + rv = NS_SUCCESS_FILE_DIRECTORY_EMPTY; + } + return rv; + } + + prefFiles.Sort(pref_CompareFileNames, nullptr); + + uint32_t arrayCount = prefFiles.Count(); + uint32_t i; + for (i = 0; i < arrayCount; ++i) { + rv2 = openPrefFile(prefFiles[i]); + if (NS_FAILED(rv2)) { + NS_ERROR("Default pref file not parsed successfully."); + rv = rv2; + } + } + + arrayCount = specialFiles.Count(); + for (i = 0; i < arrayCount; ++i) { + // this may be a sparse array; test before parsing + nsIFile* file = specialFiles[i]; + if (file) { + rv2 = openPrefFile(file); + if (NS_FAILED(rv2)) { + NS_ERROR("Special default pref file not parsed successfully."); + rv = rv2; + } + } + } + + return rv; +} + +static nsresult pref_LoadPrefsInDirList(const char *listId) +{ + nsresult 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)); + if (!list) + return NS_OK; + + bool hasMore; + while (NS_SUCCEEDED(list->HasMoreElements(&hasMore)) && hasMore) { + nsCOMPtr<nsISupports> elem; + list->GetNext(getter_AddRefs(elem)); + if (!elem) + continue; + + nsCOMPtr<nsIFile> path = do_QueryInterface(elem); + if (!path) + continue; + + nsAutoCString leaf; + path->GetNativeLeafName(leaf); + + // Do we care if a file provided by this process fails to load? + 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) +{ + nsZipItemPtr<char> manifest(jarReader, name, true); + NS_ENSURE_TRUE(manifest.Buffer(), NS_ERROR_NOT_AVAILABLE); + + PrefParseState ps; + PREF_InitParseState(&ps, PREF_ReaderCallback, ReportToConsole, nullptr); + PREF_ParseBuf(&ps, manifest, manifest.Length()); + PREF_FinalizeParseState(&ps); + + return NS_OK; +} + +//---------------------------------------------------------------------------------------- +// Initialize default preference JavaScript buffers from +// appropriate TEXT resources +//---------------------------------------------------------------------------------------- +static nsresult pref_InitInitialObjects() +{ + nsresult rv; + + // In omni.jar case, we load the following prefs: + // - jar:$gre/omni.jar!/greprefs.js + // - jar:$gre/omni.jar!/defaults/pref/*.js + // In non omni.jar case, we load: + // - $gre/greprefs.js + // + // In both cases, we also load: + // - $gre/defaults/pref/*.js + // This is kept for bug 591866 (channel-prefs.js should not be in omni.jar) + // on $app == $gre case ; we load all files instead of channel-prefs.js only + // to have the same behaviour as $app != $gre, where this is required as + // a supported location for GRE preferences. + // + // When $app != $gre, we additionally load, in omni.jar case: + // - jar:$app/omni.jar!/defaults/preferences/*.js + // - $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; + nsAutoPtr<nsZipFind> find; + nsTArray<nsCString> prefEntries; + const char *entryName; + uint16_t entryNameLen; + + 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, rv); + + // Load jar:$gre/omni.jar!/defaults/pref/*.js + rv = jarReader->FindInit("defaults/pref/*.js$", &findPtr); + NS_ENSURE_SUCCESS(rv, rv); + + find = findPtr; + while (NS_SUCCEEDED(find->FindNext(&entryName, &entryNameLen))) { + prefEntries.AppendElement(Substring(entryName, entryNameLen)); + } + + prefEntries.Sort(); + 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, rv); + + rv = greprefsFile->AppendNative(NS_LITERAL_CSTRING("greprefs.js")); + NS_ENSURE_SUCCESS(rv, rv); + + rv = openPrefFile(greprefsFile); + if (NS_FAILED(rv)) + 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)); + NS_ENSURE_SUCCESS(rv, rv); + + /* 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" +#endif +#elif defined(XP_BEOS) + "beos.js" +#endif + }; + + 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); + // 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, rv); + 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--; ) { + 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, rv); + + // 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) { + bool prerelease = false; +#ifdef MOZ_TELEMETRY_ON_BY_DEFAULT + prerelease = true; +#else + if (Preferences::GetDefaultCString(kChannelPref).EqualsLiteral("beta")) { + prerelease = true; + } +#endif + PREF_SetBoolPref(kTelemetryPref, prerelease, true); + } + + NS_CreateServicesFromCategory(NS_PREFSERVICE_APPDEFAULTS_TOPIC_ID, + nullptr, NS_PREFSERVICE_APPDEFAULTS_TOPIC_ID); + + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + if (!observerService) + return NS_ERROR_FAILURE; + + observerService->NotifyObservers(nullptr, NS_PREFSERVICE_APPDEFAULTS_TOPIC_ID, nullptr); + + return pref_LoadPrefsInDirList(NS_EXT_PREFS_DEFAULTS_DIR_LIST); +} + + +/****************************************************************************** + * + * static utilities + * + ******************************************************************************/ + +// static +nsresult +Preferences::GetBool(const char* aPref, bool* aResult) +{ + NS_PRECONDITION(aResult, "aResult must not be NULL"); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + return PREF_GetBoolPref(aPref, aResult, false); +} + +// static +nsresult +Preferences::GetInt(const char* aPref, int32_t* aResult) +{ + NS_PRECONDITION(aResult, "aResult must not be NULL"); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + return PREF_GetIntPref(aPref, aResult, false); +} + +// static +nsresult +Preferences::GetFloat(const char* aPref, float* aResult) +{ + NS_PRECONDITION(aResult, "aResult must not be NULL"); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + nsAutoCString result; + nsresult rv = PREF_CopyCharPref(aPref, getter_Copies(result), false); + if (NS_SUCCEEDED(rv)) { + *aResult = result.ToFloat(&rv); + } + + return rv; +} + +// static +nsAdoptingCString +Preferences::GetCString(const char* aPref) +{ + nsAdoptingCString result; + PREF_CopyCharPref(aPref, getter_Copies(result), false); + return result; +} + +// static +nsAdoptingString +Preferences::GetString(const char* aPref) +{ + nsAdoptingString result; + GetString(aPref, &result); + return result; +} + +// static +nsresult +Preferences::GetCString(const char* aPref, nsACString* aResult) +{ + NS_PRECONDITION(aResult, "aResult must not be NULL"); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + nsAutoCString result; + nsresult rv = PREF_CopyCharPref(aPref, getter_Copies(result), false); + if (NS_SUCCEEDED(rv)) { + *aResult = result; + } + return rv; +} + +// static +nsresult +Preferences::GetString(const char* aPref, nsAString* aResult) +{ + NS_PRECONDITION(aResult, "aResult must not be NULL"); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + nsAutoCString result; + nsresult rv = PREF_CopyCharPref(aPref, getter_Copies(result), false); + if (NS_SUCCEEDED(rv)) { + CopyUTF8toUTF16(result, *aResult); + } + return rv; +} + +// static +nsAdoptingCString +Preferences::GetLocalizedCString(const char* aPref) +{ + nsAdoptingCString result; + GetLocalizedCString(aPref, &result); + return result; +} + +// static +nsAdoptingString +Preferences::GetLocalizedString(const char* aPref) +{ + nsAdoptingString result; + GetLocalizedString(aPref, &result); + return result; +} + +// static +nsresult +Preferences::GetLocalizedCString(const char* aPref, nsACString* aResult) +{ + NS_PRECONDITION(aResult, "aResult must not be NULL"); + nsAutoString result; + nsresult rv = GetLocalizedString(aPref, &result); + if (NS_SUCCEEDED(rv)) { + CopyUTF16toUTF8(result, *aResult); + } + return rv; +} + +// static +nsresult +Preferences::GetLocalizedString(const char* aPref, nsAString* aResult) +{ + NS_PRECONDITION(aResult, "aResult must not be NULL"); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + nsCOMPtr<nsIPrefLocalizedString> 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) +{ + 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) +{ + 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 +Preferences::SetString(const char* aPref, const char16ptr_t 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 +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 +Preferences::SetBool(const char* aPref, bool aValue) +{ + ENSURE_MAIN_PROCESS("Cannot SetBool from content process:", aPref); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + return PREF_SetBoolPref(aPref, aValue, false); +} + +// static +nsresult +Preferences::SetInt(const char* aPref, int32_t aValue) +{ + ENSURE_MAIN_PROCESS("Cannot SetInt from content process:", aPref); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + return PREF_SetIntPref(aPref, aValue, false); +} + +// static +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, + nsISupports* aValue) +{ + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + return sRootBranch->SetComplexValue(aPref, aType, aValue); +} + +// static +nsresult +Preferences::ClearUser(const char* aPref) +{ + ENSURE_MAIN_PROCESS("Cannot ClearUser from content process:", aPref); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + return PREF_ClearUserPref(aPref); +} + +// static +bool +Preferences::HasUserValue(const char* aPref) +{ + NS_ENSURE_TRUE(InitStaticMembers(), false); + return PREF_HasUserPref(aPref); +} + +// 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; +} + +// static +nsresult +Preferences::AddStrongObserver(nsIObserver* aObserver, + const char* aPref) +{ + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + return sRootBranch->AddObserver(aPref, aObserver, false); +} + +// static +nsresult +Preferences::AddWeakObserver(nsIObserver* aObserver, + const char* aPref) +{ + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + return sRootBranch->AddObserver(aPref, aObserver, true); +} + +// static +nsresult +Preferences::RemoveObserver(nsIObserver* aObserver, + const char* aPref) +{ + 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) +{ + 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) +{ + 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) +{ + 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 +nsresult +Preferences::RegisterCallback(PrefChangedFunc aCallback, + const char* aPref, + void* aClosure, + MatchKind aMatchKind) +{ + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + + ValueObserverHashKey hashKey(aPref, aCallback, aMatchKind); + RefPtr<ValueObserver> observer; + gObserverTable->Get(&hashKey, getter_AddRefs(observer)); + if (observer) { + observer->AppendClosure(aClosure); + return NS_OK; + } + + observer = new ValueObserver(aPref, aCallback, aMatchKind); + observer->AppendClosure(aClosure); + nsresult rv = AddStrongObserver(observer, aPref); + NS_ENSURE_SUCCESS(rv, rv); + gObserverTable->Put(observer, observer); + return NS_OK; +} + +// static +nsresult +Preferences::RegisterCallbackAndCall(PrefChangedFunc aCallback, + const char* aPref, + void* aClosure, + MatchKind aMatchKind) +{ + nsresult rv = RegisterCallback(aCallback, aPref, aClosure, aMatchKind); + if (NS_SUCCEEDED(rv)) { + (*aCallback)(aPref, aClosure); + } + return rv; +} + +// static +nsresult +Preferences::UnregisterCallback(PrefChangedFunc aCallback, + const char* aPref, + void* aClosure, + MatchKind aMatchKind) +{ + if (!sPreferences && sShutdown) { + return NS_OK; // Observers have been released automatically. + } + NS_ENSURE_TRUE(sPreferences, NS_ERROR_NOT_AVAILABLE); + + ValueObserverHashKey hashKey(aPref, aCallback, aMatchKind); + RefPtr<ValueObserver> observer; + gObserverTable->Get(&hashKey, getter_AddRefs(observer)); + if (!observer) { + return NS_OK; + } + + observer->RemoveClosure(aClosure); + if (observer->HasNoClosures()) { + // Delete the callback since its list of closures is empty. + gObserverTable->Remove(observer); + } + return NS_OK; +} + +static void BoolVarChanged(const char* aPref, void* aClosure) +{ + CacheData* cache = static_cast<CacheData*>(aClosure); + *((bool*)cache->cacheLocation) = + Preferences::GetBool(aPref, cache->defaultValueBool); +} + +// static +nsresult +Preferences::AddBoolVarCache(bool* aCache, + const char* aPref, + bool aDefault) +{ + 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; + gCacheData->AppendElement(data); + return RegisterCallback(BoolVarChanged, aPref, data, ExactMatch); +} + +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 +Preferences::AddIntVarCache(int32_t* aCache, + const char* aPref, + int32_t aDefault) +{ + NS_ASSERTION(aCache, "aCache must not be NULL"); +#ifdef DEBUG + AssertNotAlreadyCached("int", aPref, aCache); +#endif + *aCache = Preferences::GetInt(aPref, aDefault); + CacheData* data = new CacheData(); + data->cacheLocation = aCache; + data->defaultValueInt = aDefault; + gCacheData->AppendElement(data); + return RegisterCallback(IntVarChanged, aPref, data, ExactMatch); +} + +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 +Preferences::AddUintVarCache(uint32_t* aCache, + const char* aPref, + uint32_t aDefault) +{ + NS_ASSERTION(aCache, "aCache must not be NULL"); +#ifdef DEBUG + AssertNotAlreadyCached("uint", aPref, aCache); +#endif + *aCache = Preferences::GetUint(aPref, aDefault); + CacheData* data = new CacheData(); + data->cacheLocation = aCache; + data->defaultValueUint = aDefault; + gCacheData->AppendElement(data); + return RegisterCallback(UintVarChanged, aPref, data, ExactMatch); +} + +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> +// static +nsresult +Preferences::AddAtomicUintVarCache(Atomic<uint32_t, Order>* aCache, + const char* aPref, + uint32_t aDefault) +{ + NS_ASSERTION(aCache, "aCache must not be NULL"); +#ifdef DEBUG + AssertNotAlreadyCached("uint", aPref, aCache); +#endif + *aCache = Preferences::GetUint(aPref, aDefault); + CacheData* data = new CacheData(); + data->cacheLocation = aCache; + data->defaultValueUint = aDefault; + gCacheData->AppendElement(data); + return RegisterCallback(AtomicUintVarChanged<Order>, aPref, data, ExactMatch); +} + +// 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); + +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) +{ + NS_ASSERTION(aCache, "aCache must not be NULL"); +#ifdef DEBUG + AssertNotAlreadyCached("float", aPref, aCache); +#endif + *aCache = Preferences::GetFloat(aPref, aDefault); + CacheData* data = new CacheData(); + data->cacheLocation = aCache; + data->defaultValueFloat = aDefault; + gCacheData->AppendElement(data); + return RegisterCallback(FloatVarChanged, aPref, data, ExactMatch); +} + +// static +nsresult +Preferences::GetDefaultBool(const char* aPref, bool* aResult) +{ + NS_PRECONDITION(aResult, "aResult must not be NULL"); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + return PREF_GetBoolPref(aPref, aResult, true); +} + +// static +nsresult +Preferences::GetDefaultInt(const char* aPref, int32_t* aResult) +{ + NS_PRECONDITION(aResult, "aResult must not be NULL"); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + return PREF_GetIntPref(aPref, aResult, true); +} + +// static +nsresult +Preferences::GetDefaultCString(const char* aPref, nsACString* aResult) +{ + NS_PRECONDITION(aResult, "aResult must not be NULL"); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + nsAutoCString result; + nsresult rv = PREF_CopyCharPref(aPref, getter_Copies(result), true); + if (NS_SUCCEEDED(rv)) { + *aResult = result; + } + return rv; +} + +// static +nsresult +Preferences::GetDefaultString(const char* aPref, nsAString* aResult) +{ + NS_PRECONDITION(aResult, "aResult must not be NULL"); + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + nsAutoCString result; + nsresult rv = PREF_CopyCharPref(aPref, getter_Copies(result), true); + if (NS_SUCCEEDED(rv)) { + CopyUTF8toUTF16(result, *aResult); + } + return rv; +} + +// static +nsresult +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) +{ + NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE); + nsCOMPtr<nsIPrefLocalizedString> 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 +nsAdoptingString +Preferences::GetDefaultString(const char* aPref) +{ + nsAdoptingString result; + GetDefaultString(aPref, &result); + return result; +} + +// static +nsAdoptingCString +Preferences::GetDefaultCString(const char* aPref) +{ + nsAdoptingCString result; + PREF_CopyCharPref(aPref, getter_Copies(result), true); + return result; +} + +// static +nsAdoptingString +Preferences::GetDefaultLocalizedString(const char* aPref) +{ + nsAdoptingString result; + GetDefaultLocalizedString(aPref, &result); + return result; +} + +// static +nsAdoptingCString +Preferences::GetDefaultLocalizedCString(const char* aPref) +{ + nsAdoptingCString result; + GetDefaultLocalizedCString(aPref, &result); + return result; +} + +// static +nsresult +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; +} + +} // namespace mozilla + +#undef ENSURE_MAIN_PROCESS |