mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-20 16:55:40 +00:00
8e4b8a954f
Most preference callbacks use literal strings for their domain filters, which means that there's no need to make copies of them at all. Currently, however, every preference observer node makes a separate heap-allocated copy of its domain string. This patch switches the domain string storage to nsCString instances, which dramatically reduces the amount of unnecessary copies, at the expense of making the callback nodes slightly larger. MozReview-Commit-ID: 8NA3t2JS2UI --HG-- extra : rebase_source : 628ad9af65cec16fb8be0c8dddc608b5ee5602e2
522 lines
19 KiB
C++
522 lines
19 KiB
C++
/* -*- 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/. */
|
|
|
|
#ifndef mozilla_Preferences_h
|
|
#define mozilla_Preferences_h
|
|
|
|
#ifndef MOZILLA_INTERNAL_API
|
|
#error "This header is only usable from within libxul (MOZILLA_INTERNAL_API)."
|
|
#endif
|
|
|
|
#include "mozilla/Atomics.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/Result.h"
|
|
#include "mozilla/StaticPtr.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsIObserver.h"
|
|
#include "nsIPrefBranch.h"
|
|
#include "nsIPrefService.h"
|
|
#include "nsPrintfCString.h"
|
|
#include "nsString.h"
|
|
#include "nsTArray.h"
|
|
#include "nsWeakReference.h"
|
|
|
|
class nsIFile;
|
|
|
|
// The callback function will get passed the pref name which triggered the call
|
|
// and the void* data which was passed to the registered callback function.
|
|
typedef void (*PrefChangedFunc)(const char* aPref, void* aData);
|
|
|
|
class nsPrefBranch;
|
|
|
|
namespace mozilla {
|
|
|
|
namespace dom {
|
|
class Pref;
|
|
class PrefValue;
|
|
} // namespace dom
|
|
|
|
struct PrefsSizes;
|
|
|
|
#ifdef XP_UNIX
|
|
// XXX: bug 1440207 is about improving how fixed fds such as this are used.
|
|
static const int kPrefsFileDescriptor = 8;
|
|
#endif
|
|
|
|
// Keep this in sync with PrefType in parser/src/lib.rs.
|
|
enum class PrefValueKind : uint8_t
|
|
{
|
|
Default,
|
|
User
|
|
};
|
|
|
|
class Preferences final
|
|
: public nsIPrefService
|
|
, public nsIObserver
|
|
, public nsIPrefBranch
|
|
, public nsSupportsWeakReference
|
|
{
|
|
friend class ::nsPrefBranch;
|
|
|
|
public:
|
|
NS_DECL_THREADSAFE_ISUPPORTS
|
|
NS_DECL_NSIPREFSERVICE
|
|
NS_FORWARD_NSIPREFBRANCH(mRootBranch->)
|
|
NS_DECL_NSIOBSERVER
|
|
|
|
Preferences();
|
|
|
|
// Returns true if the Preferences service is available, false otherwise.
|
|
static bool IsServiceAvailable();
|
|
|
|
// Initialize user prefs from prefs.js/user.js
|
|
static void InitializeUserPrefs();
|
|
|
|
// Returns the singleton instance which is addreffed.
|
|
static already_AddRefed<Preferences> GetInstanceForService();
|
|
|
|
// Finallizes global members.
|
|
static void Shutdown();
|
|
|
|
// Returns shared pref service instance NOTE: not addreffed.
|
|
static nsIPrefService* GetService()
|
|
{
|
|
NS_ENSURE_TRUE(InitStaticMembers(), nullptr);
|
|
return sPreferences;
|
|
}
|
|
|
|
// Returns shared pref branch instance. NOTE: not addreffed.
|
|
static nsIPrefBranch* GetRootBranch(PrefValueKind aKind = PrefValueKind::User)
|
|
{
|
|
NS_ENSURE_TRUE(InitStaticMembers(), nullptr);
|
|
return (aKind == PrefValueKind::Default) ? sPreferences->mDefaultRootBranch
|
|
: sPreferences->mRootBranch;
|
|
}
|
|
|
|
// Gets the type of the pref.
|
|
static int32_t GetType(const char* aPrefName);
|
|
|
|
// Fallible value getters. When `aKind` is `User` they will get the user
|
|
// value if possible, and fall back to the default value otherwise.
|
|
static nsresult GetBool(const char* aPrefName,
|
|
bool* aResult,
|
|
PrefValueKind aKind = PrefValueKind::User);
|
|
static nsresult GetInt(const char* aPrefName,
|
|
int32_t* aResult,
|
|
PrefValueKind aKind = PrefValueKind::User);
|
|
static nsresult GetUint(const char* aPrefName,
|
|
uint32_t* aResult,
|
|
PrefValueKind aKind = PrefValueKind::User)
|
|
{
|
|
return GetInt(aPrefName, reinterpret_cast<int32_t*>(aResult), aKind);
|
|
}
|
|
static nsresult GetFloat(const char* aPrefName,
|
|
float* aResult,
|
|
PrefValueKind aKind = PrefValueKind::User);
|
|
static nsresult GetCString(const char* aPrefName,
|
|
nsACString& aResult,
|
|
PrefValueKind aKind = PrefValueKind::User);
|
|
static nsresult GetString(const char* aPrefName,
|
|
nsAString& aResult,
|
|
PrefValueKind aKind = PrefValueKind::User);
|
|
static nsresult GetLocalizedCString(
|
|
const char* aPrefName,
|
|
nsACString& aResult,
|
|
PrefValueKind aKind = PrefValueKind::User);
|
|
static nsresult GetLocalizedString(const char* aPrefName,
|
|
nsAString& aResult,
|
|
PrefValueKind aKind = PrefValueKind::User);
|
|
static nsresult GetComplex(const char* aPrefName,
|
|
const nsIID& aType,
|
|
void** aResult,
|
|
PrefValueKind aKind = PrefValueKind::User);
|
|
|
|
// Infallible getters of user or default values, with fallback results on
|
|
// failure. When `aKind` is `User` they will get the user value if possible,
|
|
// and fall back to the default value otherwise.
|
|
static bool GetBool(const char* aPrefName,
|
|
bool aFallback = false,
|
|
PrefValueKind aKind = PrefValueKind::User)
|
|
{
|
|
bool result = aFallback;
|
|
GetBool(aPrefName, &result, aKind);
|
|
return result;
|
|
}
|
|
static int32_t GetInt(const char* aPrefName,
|
|
int32_t aFallback = 0,
|
|
PrefValueKind aKind = PrefValueKind::User)
|
|
{
|
|
int32_t result = aFallback;
|
|
GetInt(aPrefName, &result, aKind);
|
|
return result;
|
|
}
|
|
static uint32_t GetUint(const char* aPrefName,
|
|
uint32_t aFallback = 0,
|
|
PrefValueKind aKind = PrefValueKind::User)
|
|
{
|
|
uint32_t result = aFallback;
|
|
GetUint(aPrefName, &result, aKind);
|
|
return result;
|
|
}
|
|
static float GetFloat(const char* aPrefName,
|
|
float aFallback = 0.0f,
|
|
PrefValueKind aKind = PrefValueKind::User)
|
|
{
|
|
float result = aFallback;
|
|
GetFloat(aPrefName, &result, aKind);
|
|
return result;
|
|
}
|
|
|
|
// Value setters. These fail if run outside the parent process.
|
|
|
|
static nsresult SetBool(const char* aPrefName,
|
|
bool aValue,
|
|
PrefValueKind aKind = PrefValueKind::User);
|
|
static nsresult SetInt(const char* aPrefName,
|
|
int32_t aValue,
|
|
PrefValueKind aKind = PrefValueKind::User);
|
|
static nsresult SetCString(const char* aPrefName,
|
|
const nsACString& aValue,
|
|
PrefValueKind aKind = PrefValueKind::User);
|
|
|
|
static nsresult SetUint(const char* aPrefName,
|
|
uint32_t aValue,
|
|
PrefValueKind aKind = PrefValueKind::User)
|
|
{
|
|
return SetInt(aPrefName, static_cast<int32_t>(aValue), aKind);
|
|
}
|
|
|
|
static nsresult SetFloat(const char* aPrefName,
|
|
float aValue,
|
|
PrefValueKind aKind = PrefValueKind::User)
|
|
{
|
|
return SetCString(aPrefName, nsPrintfCString("%f", aValue), aKind);
|
|
}
|
|
|
|
static nsresult SetCString(const char* aPrefName,
|
|
const char* aValue,
|
|
PrefValueKind aKind = PrefValueKind::User)
|
|
{
|
|
return Preferences::SetCString(
|
|
aPrefName, nsDependentCString(aValue), aKind);
|
|
}
|
|
|
|
static nsresult SetString(const char* aPrefName,
|
|
const char16ptr_t aValue,
|
|
PrefValueKind aKind = PrefValueKind::User)
|
|
{
|
|
return Preferences::SetCString(
|
|
aPrefName, NS_ConvertUTF16toUTF8(aValue), aKind);
|
|
}
|
|
|
|
static nsresult SetString(const char* aPrefName,
|
|
const nsAString& aValue,
|
|
PrefValueKind aKind = PrefValueKind::User)
|
|
{
|
|
return Preferences::SetCString(
|
|
aPrefName, NS_ConvertUTF16toUTF8(aValue), aKind);
|
|
}
|
|
|
|
static nsresult SetComplex(const char* aPrefName,
|
|
const nsIID& aType,
|
|
nsISupports* aValue,
|
|
PrefValueKind aKind = PrefValueKind::User);
|
|
|
|
static nsresult Lock(const char* aPrefName);
|
|
static nsresult Unlock(const char* aPrefName);
|
|
static bool IsLocked(const char* aPrefName);
|
|
|
|
// Clears user set pref. Fails if run outside the parent process.
|
|
static nsresult ClearUser(const char* aPrefName);
|
|
|
|
// Whether the pref has a user value or not.
|
|
static bool HasUserValue(const char* aPref);
|
|
|
|
// Adds/Removes the observer for the root pref branch. See nsIPrefBranch.idl
|
|
// for details.
|
|
static nsresult AddStrongObserver(nsIObserver* aObserver, const char* aPref);
|
|
static nsresult AddWeakObserver(nsIObserver* aObserver, const char* aPref);
|
|
static nsresult RemoveObserver(nsIObserver* aObserver, const char* aPref);
|
|
|
|
// Adds/Removes two or more observers for the root pref branch. Pass to
|
|
// aPrefs an array of const char* whose last item is nullptr.
|
|
static nsresult AddStrongObservers(nsIObserver* aObserver,
|
|
const char** aPrefs);
|
|
static nsresult AddWeakObservers(nsIObserver* aObserver, const char** aPrefs);
|
|
static nsresult RemoveObservers(nsIObserver* aObserver, const char** aPrefs);
|
|
|
|
// Registers/Unregisters the callback function for the aPref.
|
|
static nsresult RegisterCallback(PrefChangedFunc aCallback,
|
|
const nsACString& aPref,
|
|
void* aClosure = nullptr)
|
|
{
|
|
return RegisterCallback(aCallback, aPref, aClosure, ExactMatch);
|
|
}
|
|
|
|
static nsresult UnregisterCallback(PrefChangedFunc aCallback,
|
|
const nsACString& aPref,
|
|
void* aClosure = nullptr)
|
|
{
|
|
return UnregisterCallback(aCallback, aPref, aClosure, ExactMatch);
|
|
}
|
|
|
|
// Like RegisterCallback, but also calls the callback immediately for
|
|
// initialization.
|
|
static nsresult RegisterCallbackAndCall(PrefChangedFunc aCallback,
|
|
const nsACString& aPref,
|
|
void* aClosure = nullptr)
|
|
{
|
|
return RegisterCallbackAndCall(aCallback, aPref, aClosure, ExactMatch);
|
|
}
|
|
|
|
// Like RegisterCallback, but registers a callback for a prefix of multiple
|
|
// pref names, not a single pref name.
|
|
static nsresult RegisterPrefixCallback(PrefChangedFunc aCallback,
|
|
const nsACString& aPref,
|
|
void* aClosure = nullptr)
|
|
{
|
|
return RegisterCallback(aCallback, aPref, aClosure, PrefixMatch);
|
|
}
|
|
|
|
// Like RegisterPrefixCallback, but also calls the callback immediately for
|
|
// initialization.
|
|
static nsresult RegisterPrefixCallbackAndCall(PrefChangedFunc aCallback,
|
|
const nsACString& aPref,
|
|
void* aClosure = nullptr)
|
|
{
|
|
return RegisterCallbackAndCall(aCallback, aPref, aClosure, PrefixMatch);
|
|
}
|
|
|
|
// Unregister a callback registered with RegisterPrefixCallback or
|
|
// RegisterPrefixCallbackAndCall.
|
|
static nsresult UnregisterPrefixCallback(PrefChangedFunc aCallback,
|
|
const nsACString& aPref,
|
|
void* aClosure = nullptr)
|
|
{
|
|
return UnregisterCallback(aCallback, aPref, aClosure, PrefixMatch);
|
|
}
|
|
|
|
template<int N>
|
|
static nsresult RegisterCallback(PrefChangedFunc aCallback,
|
|
const char (&aPref)[N],
|
|
void* aClosure = nullptr)
|
|
{
|
|
return RegisterCallback(
|
|
aCallback, nsLiteralCString(aPref), aClosure, ExactMatch);
|
|
}
|
|
|
|
template<int N>
|
|
static nsresult UnregisterCallback(PrefChangedFunc aCallback,
|
|
const char (&aPref)[N],
|
|
void* aClosure = nullptr)
|
|
{
|
|
return UnregisterCallback(
|
|
aCallback, nsLiteralCString(aPref), aClosure, ExactMatch);
|
|
}
|
|
|
|
template<int N>
|
|
static nsresult RegisterCallbackAndCall(PrefChangedFunc aCallback,
|
|
const char (&aPref)[N],
|
|
void* aClosure = nullptr)
|
|
{
|
|
return RegisterCallbackAndCall(
|
|
aCallback, nsLiteralCString(aPref), aClosure, ExactMatch);
|
|
}
|
|
|
|
template<int N>
|
|
static nsresult RegisterPrefixCallback(PrefChangedFunc aCallback,
|
|
const char (&aPref)[N],
|
|
void* aClosure = nullptr)
|
|
{
|
|
return RegisterCallback(
|
|
aCallback, nsLiteralCString(aPref), aClosure, PrefixMatch);
|
|
}
|
|
|
|
template<int N>
|
|
static nsresult RegisterPrefixCallbackAndCall(PrefChangedFunc aCallback,
|
|
const char (&aPref)[N],
|
|
void* aClosure = nullptr)
|
|
{
|
|
return RegisterCallbackAndCall(
|
|
aCallback, nsLiteralCString(aPref), aClosure, PrefixMatch);
|
|
}
|
|
|
|
template<int N>
|
|
static nsresult UnregisterPrefixCallback(PrefChangedFunc aCallback,
|
|
const char (&aPref)[N],
|
|
void* aClosure = nullptr)
|
|
{
|
|
return UnregisterCallback(
|
|
aCallback, nsLiteralCString(aPref), aClosure, PrefixMatch);
|
|
}
|
|
|
|
// Adds the aVariable to cache table. |aVariable| must be a pointer for a
|
|
// static variable. The value will be modified when the pref value is changed
|
|
// but note that even if you modified it, the value isn't assigned to the
|
|
// pref.
|
|
static nsresult AddBoolVarCache(bool* aVariable,
|
|
const char* aPref,
|
|
bool aDefault = false,
|
|
bool aSkipAssignment = false);
|
|
template<MemoryOrdering Order>
|
|
static nsresult AddAtomicBoolVarCache(Atomic<bool, Order>* aVariable,
|
|
const char* aPref,
|
|
bool aDefault = false,
|
|
bool aSkipAssignment = false);
|
|
static nsresult AddIntVarCache(int32_t* aVariable,
|
|
const char* aPref,
|
|
int32_t aDefault = 0,
|
|
bool aSkipAssignment = false);
|
|
template<MemoryOrdering Order>
|
|
static nsresult AddAtomicIntVarCache(Atomic<int32_t, Order>* aVariable,
|
|
const char* aPref,
|
|
int32_t aDefault = 0,
|
|
bool aSkipAssignment = false);
|
|
static nsresult AddUintVarCache(uint32_t* aVariable,
|
|
const char* aPref,
|
|
uint32_t aDefault = 0,
|
|
bool aSkipAssignment = false);
|
|
template<MemoryOrdering Order>
|
|
static nsresult AddAtomicUintVarCache(Atomic<uint32_t, Order>* aVariable,
|
|
const char* aPref,
|
|
uint32_t aDefault = 0,
|
|
bool aSkipAssignment = false);
|
|
static nsresult AddFloatVarCache(float* aVariable,
|
|
const char* aPref,
|
|
float aDefault = 0.0f,
|
|
bool aSkipAssignment = false);
|
|
|
|
// When a content process is created these methods are used to pass changed
|
|
// prefs in bulk from the parent process, via shared memory.
|
|
static void SerializePreferences(nsCString& aStr);
|
|
static void DeserializePreferences(char* aStr, size_t aPrefsLen);
|
|
|
|
// When a single pref is changed in the parent process, these methods are
|
|
// used to pass the update to content processes.
|
|
static void GetPreference(dom::Pref* aPref);
|
|
static void SetPreference(const dom::Pref& aPref);
|
|
|
|
#ifdef DEBUG
|
|
static bool ArePrefsInitedInContentProcess();
|
|
#endif
|
|
|
|
static void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
|
|
PrefsSizes& aSizes);
|
|
|
|
static void HandleDirty();
|
|
|
|
// Explicitly choosing synchronous or asynchronous (if allowed) preferences
|
|
// file write. Only for the default file. The guarantee for the "blocking"
|
|
// is that when it returns, the file on disk reflect the current state of
|
|
// preferences.
|
|
nsresult SavePrefFileBlocking();
|
|
nsresult SavePrefFileAsynchronous();
|
|
|
|
private:
|
|
virtual ~Preferences();
|
|
|
|
nsresult NotifyServiceObservers(const char* aSubject);
|
|
|
|
// Loads the prefs.js file from the profile, or creates a new one. Returns
|
|
// the prefs file if successful, or nullptr on failure.
|
|
already_AddRefed<nsIFile> ReadSavedPrefs();
|
|
|
|
// Loads the user.js file from the profile if present.
|
|
void ReadUserOverridePrefs();
|
|
|
|
nsresult MakeBackupPrefFile(nsIFile* aFile);
|
|
|
|
// Default pref file save can be blocking or not.
|
|
enum class SaveMethod
|
|
{
|
|
Blocking,
|
|
Asynchronous
|
|
};
|
|
|
|
// Off main thread is only respected for the default aFile value (nullptr).
|
|
nsresult SavePrefFileInternal(nsIFile* aFile, SaveMethod aSaveMethod);
|
|
nsresult WritePrefFile(nsIFile* aFile, SaveMethod aSaveMethod);
|
|
|
|
// If this is false, only blocking writes, on main thread are allowed.
|
|
bool AllowOffMainThreadSave();
|
|
|
|
// Helpers for implementing
|
|
// Register(Prefix)Callback/Unregister(Prefix)Callback.
|
|
public:
|
|
// Public so the ValueObserver classes can use it.
|
|
enum MatchKind
|
|
{
|
|
PrefixMatch,
|
|
ExactMatch,
|
|
};
|
|
|
|
private:
|
|
static void SetupTelemetryPref();
|
|
static mozilla::Result<mozilla::Ok, const char*> InitInitialObjects(
|
|
bool aIsStartup);
|
|
|
|
static nsresult RegisterCallback(PrefChangedFunc aCallback,
|
|
const nsACString& aPref,
|
|
void* aClosure,
|
|
MatchKind aMatchKind,
|
|
bool aIsPriority = false);
|
|
static nsresult UnregisterCallback(PrefChangedFunc aCallback,
|
|
const nsACString& aPref,
|
|
void* aClosure,
|
|
MatchKind aMatchKind);
|
|
static nsresult RegisterCallbackAndCall(PrefChangedFunc aCallback,
|
|
const nsACString& aPref,
|
|
void* aClosure,
|
|
MatchKind aMatchKind);
|
|
|
|
static nsresult RegisterCallback(PrefChangedFunc aCallback,
|
|
const char* aPref,
|
|
void* aClosure,
|
|
MatchKind aMatchKind,
|
|
bool aIsPriority = false)
|
|
{
|
|
return RegisterCallback(
|
|
aCallback, nsDependentCString(aPref), aClosure, aMatchKind, aIsPriority);
|
|
}
|
|
static nsresult UnregisterCallback(PrefChangedFunc aCallback,
|
|
const char* aPref,
|
|
void* aClosure,
|
|
MatchKind aMatchKind)
|
|
{
|
|
return UnregisterCallback(
|
|
aCallback, nsDependentCString(aPref), aClosure, aMatchKind);
|
|
}
|
|
static nsresult RegisterCallbackAndCall(PrefChangedFunc aCallback,
|
|
const char* aPref,
|
|
void* aClosure,
|
|
MatchKind aMatchKind)
|
|
{
|
|
return RegisterCallbackAndCall(
|
|
aCallback, nsDependentCString(aPref), aClosure, aMatchKind);
|
|
}
|
|
|
|
private:
|
|
nsCOMPtr<nsIFile> mCurrentFile;
|
|
bool mDirty = false;
|
|
bool mProfileShutdown = false;
|
|
// We wait a bit after prefs are dirty before writing them. In this period,
|
|
// mDirty and mSavePending will both be true.
|
|
bool mSavePending = false;
|
|
|
|
nsCOMPtr<nsIPrefBranch> mRootBranch;
|
|
nsCOMPtr<nsIPrefBranch> mDefaultRootBranch;
|
|
|
|
static StaticRefPtr<Preferences> sPreferences;
|
|
static bool sShutdown;
|
|
|
|
// Init static members. Returns true on success.
|
|
static bool InitStaticMembers();
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_Preferences_h
|