mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-20 16:55:40 +00:00
8d585408dc
I also tried to avoid this change but, again, given the number of times I was repeating the same pattern of defining a static method just to forward a callback to an instance method, decided it was probably necessary. Without an easy way to do this, people are more likely to register observers rather than callbacks, for which we'll wind up paying a continued memory and performance penalty. This patch adds a helper which creates a type-safe preference callback function which forwards calls to an instance method on its closure object. The implementation is somewhat complicated, mainly due to the constraint that unregistering a callback requires passing the exact same function pointer that was used to register it. The patch achieves this by creating the callback function as a template, with the method pointer as a template parameter. As long as the Register and Unregister calls happen in the same translation unit, the same template instance is guaranteed to be used for both. The main difficulty is that, until C++ 17, there's no way match a value as a template parameter unless you know its complete type, or can at least compute its complete type based on earlier template parameters. That means that we need a macro to extract the type of the method, and construct the template with the full set of explicit parameters. MozReview-Commit-ID: 10N3R2SRtPc --HG-- extra : rebase_source : 7d0a8ddeb77e01d4a6f421459514e93bc0875598
812 lines
29 KiB
C++
812 lines
29 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 {
|
|
|
|
// A typesafe version of PrefChangeFunc, with its data argument type deduced
|
|
// from the type of the argument passed to RegisterCallback.
|
|
//
|
|
// Note: We specify this as a dependent type TypedPrefChangeFunc<T>::SelfType so
|
|
// that it does not participate in argument type deduction. This allows us to
|
|
// use its implicit conversion constructor, and also allows our Register and
|
|
// Unregister methods to accept non-capturing lambdas (which will not match
|
|
// void(*)(const char*, T*) when used in type deduction) as callback functions.
|
|
template<typename T>
|
|
struct TypedPrefChangeFunc
|
|
{
|
|
using Type = TypedPrefChangeFunc<T>;
|
|
using CallbackType = void (*)(const char*, T*);
|
|
|
|
MOZ_IMPLICIT TypedPrefChangeFunc(CallbackType aCallback)
|
|
: mCallback(aCallback)
|
|
{
|
|
}
|
|
|
|
template<typename F>
|
|
MOZ_IMPLICIT TypedPrefChangeFunc(F&& aLambda)
|
|
: mCallback(aLambda)
|
|
{
|
|
}
|
|
|
|
operator PrefChangedFunc() const
|
|
{
|
|
return reinterpret_cast<PrefChangedFunc>(mCallback);
|
|
}
|
|
|
|
CallbackType mCallback;
|
|
};
|
|
|
|
// Similar to PrefChangedFunc, but for use with instance methods.
|
|
//
|
|
// Any instance method with this signature may be passed to the
|
|
// PREF_CHANGE_METHOD macro, which will wrap it into a typesafe preference
|
|
// callback function, which accepts a preference name as its first argument, and
|
|
// an instance of the appropriate class as the second.
|
|
//
|
|
// When called, the wrapper will forward the call to the wrapped method on the
|
|
// given instance, with the notified preference as its only argument.
|
|
typedef void(PrefChangedMethod)(const char* aPref);
|
|
|
|
namespace detail {
|
|
// Helper to extract the instance type from any instance method. For an instance
|
|
// method `Method = U T::*`, InstanceType<Method>::Type returns T.
|
|
template<typename T>
|
|
struct InstanceType;
|
|
|
|
template<typename T, typename U>
|
|
struct InstanceType<U T::*>
|
|
{
|
|
using Type = T;
|
|
};
|
|
|
|
// A wrapper for a PrefChangeMethod instance method which forwards calls to the
|
|
// wrapped method on the given instance.
|
|
template<typename T, PrefChangedMethod T::*Method>
|
|
void
|
|
PrefChangeMethod(const char* aPref, T* aInst)
|
|
{
|
|
((*aInst).*Method)(aPref);
|
|
}
|
|
} // namespace detail
|
|
|
|
// Creates a wrapper around an instance method, with the signature of
|
|
// PrefChangedMethod, from an arbitrary class, so that it can be used as a
|
|
// preference callback. The closure data passed to RegisterCallback must be an
|
|
// instance of this class.
|
|
//
|
|
// Note: This is implemented as a macro rather than a pure template function
|
|
// because, prior to C++17, value template arguments must have their types
|
|
// fully-specified. Once all of our supported compilers have C++17 support, we
|
|
// can give PrefChangeMethod a single <auto Method> argument, and use
|
|
// PrefChangeMethod<&meth> directly.
|
|
#define PREF_CHANGE_METHOD(meth) \
|
|
(&::mozilla::detail::PrefChangeMethod< \
|
|
::mozilla::detail::InstanceType<decltype(&meth)>::Type, \
|
|
&meth>)
|
|
|
|
class PreferenceServiceReporter;
|
|
|
|
namespace dom {
|
|
class Pref;
|
|
class PrefValue;
|
|
} // namespace dom
|
|
|
|
namespace ipc {
|
|
class FileDescriptor;
|
|
} // namespace ipc
|
|
|
|
struct PrefsSizes;
|
|
|
|
// Xlib.h defines Bool as a macro constant. Don't try to define this enum if
|
|
// it's already been included.
|
|
#ifndef Bool
|
|
|
|
// Keep this in sync with PrefType in parser/src/lib.rs.
|
|
enum class PrefType : uint8_t
|
|
{
|
|
None = 0, // only used when neither the default nor user value is set
|
|
String = 1,
|
|
Int = 2,
|
|
Bool = 3,
|
|
};
|
|
|
|
#endif
|
|
|
|
#ifdef XP_UNIX
|
|
// We need to send two shared memory descriptors to every child process:
|
|
//
|
|
// 1) A read-only/write-protected snapshot of the initial state of the
|
|
// preference database. This memory is shared between all processes, and
|
|
// therefore cannot be modified once it has been created.
|
|
//
|
|
// 2) A set of changes on top of the snapshot, containing the current values of
|
|
// all preferences which have changed since it was created.
|
|
//
|
|
// Since the second set will be different for every process, and the first set
|
|
// cannot be modified, it is unfortunately not possible to combine them into a
|
|
// single file descriptor.
|
|
//
|
|
// XXX: bug 1440207 is about improving how fixed fds such as this are used.
|
|
static const int kPrefsFileDescriptor = 8;
|
|
static const int kPrefMapFileDescriptor = 9;
|
|
#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 nsACString& aPref);
|
|
static nsresult AddWeakObserver(nsIObserver* aObserver,
|
|
const nsACString& aPref);
|
|
static nsresult RemoveObserver(nsIObserver* aObserver,
|
|
const nsACString& aPref);
|
|
|
|
template<int N>
|
|
static nsresult AddStrongObserver(nsIObserver* aObserver,
|
|
const char (&aPref)[N])
|
|
{
|
|
return AddStrongObserver(aObserver, nsLiteralCString(aPref));
|
|
}
|
|
template<int N>
|
|
static nsresult AddWeakObserver(nsIObserver* aObserver,
|
|
const char (&aPref)[N])
|
|
{
|
|
return AddWeakObserver(aObserver, nsLiteralCString(aPref));
|
|
}
|
|
template<int N>
|
|
static nsresult RemoveObserver(nsIObserver* aObserver, const char (&aPref)[N])
|
|
{
|
|
return RemoveObserver(aObserver, nsLiteralCString(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.
|
|
// Note: All preference strings *must* be statically-allocated string
|
|
// literals.
|
|
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.
|
|
template<typename T = void>
|
|
static nsresult RegisterCallback(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const nsACString& aPref,
|
|
T* aClosure = nullptr)
|
|
{
|
|
return RegisterCallback(aCallback, aPref, aClosure, ExactMatch);
|
|
}
|
|
|
|
template<typename T = void>
|
|
static nsresult UnregisterCallback(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const nsACString& aPref,
|
|
T* aClosure = nullptr)
|
|
{
|
|
return UnregisterCallback(aCallback, aPref, aClosure, ExactMatch);
|
|
}
|
|
|
|
// Like RegisterCallback, but also calls the callback immediately for
|
|
// initialization.
|
|
template<typename T = void>
|
|
static nsresult RegisterCallbackAndCall(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const nsACString& aPref,
|
|
T* 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.
|
|
template<typename T = void>
|
|
static nsresult RegisterPrefixCallback(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const nsACString& aPref,
|
|
T* aClosure = nullptr)
|
|
{
|
|
return RegisterCallback(aCallback, aPref, aClosure, PrefixMatch);
|
|
}
|
|
|
|
// Like RegisterPrefixCallback, but also calls the callback immediately for
|
|
// initialization.
|
|
template<typename T = void>
|
|
static nsresult RegisterPrefixCallbackAndCall(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const nsACString& aPref,
|
|
T* aClosure = nullptr)
|
|
{
|
|
return RegisterCallbackAndCall(aCallback, aPref, aClosure, PrefixMatch);
|
|
}
|
|
|
|
// Unregister a callback registered with RegisterPrefixCallback or
|
|
// RegisterPrefixCallbackAndCall.
|
|
template<typename T = void>
|
|
static nsresult UnregisterPrefixCallback(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const nsACString& aPref,
|
|
T* aClosure = nullptr)
|
|
{
|
|
return UnregisterCallback(aCallback, aPref, aClosure, PrefixMatch);
|
|
}
|
|
|
|
// Variants of the above which register a single callback to handle multiple
|
|
// preferences.
|
|
//
|
|
// The array of preference names must be null terminated. It may be
|
|
// dynamically allocated, but the caller is responsible for keeping it alive
|
|
// until the callback is unregistered.
|
|
//
|
|
// Also note that the exact same aPrefs pointer must be passed to the
|
|
// Unregister call as was passed to the Register call.
|
|
template<typename T = void>
|
|
static nsresult RegisterCallbacks(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const char** aPrefs,
|
|
T* aClosure = nullptr)
|
|
{
|
|
return RegisterCallbacks(aCallback, aPrefs, aClosure, ExactMatch);
|
|
}
|
|
static nsresult RegisterCallbacksAndCall(PrefChangedFunc aCallback,
|
|
const char** aPrefs,
|
|
void* aClosure = nullptr);
|
|
template<typename T = void>
|
|
static nsresult UnregisterCallbacks(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const char** aPrefs,
|
|
T* aClosure = nullptr)
|
|
{
|
|
return UnregisterCallbacks(aCallback, aPrefs, aClosure, ExactMatch);
|
|
}
|
|
template<typename T = void>
|
|
static nsresult RegisterPrefixCallbacks(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const char** aPrefs,
|
|
T* aClosure = nullptr)
|
|
{
|
|
return RegisterCallbacks(aCallback, aPrefs, aClosure, PrefixMatch);
|
|
}
|
|
template<typename T = void>
|
|
static nsresult UnregisterPrefixCallbacks(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const char** aPrefs,
|
|
T* aClosure = nullptr)
|
|
{
|
|
return UnregisterCallbacks(aCallback, aPrefs, aClosure, PrefixMatch);
|
|
}
|
|
|
|
template<int N, typename T = void>
|
|
static nsresult RegisterCallback(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const char (&aPref)[N],
|
|
T* aClosure = nullptr)
|
|
{
|
|
return RegisterCallback(
|
|
aCallback, nsLiteralCString(aPref), aClosure, ExactMatch);
|
|
}
|
|
|
|
template<int N, typename T = void>
|
|
static nsresult UnregisterCallback(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const char (&aPref)[N],
|
|
T* aClosure = nullptr)
|
|
{
|
|
return UnregisterCallback(
|
|
aCallback, nsLiteralCString(aPref), aClosure, ExactMatch);
|
|
}
|
|
|
|
template<int N, typename T = void>
|
|
static nsresult RegisterCallbackAndCall(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const char (&aPref)[N],
|
|
T* aClosure = nullptr)
|
|
{
|
|
return RegisterCallbackAndCall(
|
|
aCallback, nsLiteralCString(aPref), aClosure, ExactMatch);
|
|
}
|
|
|
|
template<int N, typename T = void>
|
|
static nsresult RegisterPrefixCallback(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const char (&aPref)[N],
|
|
T* aClosure = nullptr)
|
|
{
|
|
return RegisterCallback(
|
|
aCallback, nsLiteralCString(aPref), aClosure, PrefixMatch);
|
|
}
|
|
|
|
template<int N, typename T = void>
|
|
static nsresult RegisterPrefixCallbackAndCall(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const char (&aPref)[N],
|
|
T* aClosure = nullptr)
|
|
{
|
|
return RegisterCallbackAndCall(
|
|
aCallback, nsLiteralCString(aPref), aClosure, PrefixMatch);
|
|
}
|
|
|
|
template<int N, typename T = void>
|
|
static nsresult UnregisterPrefixCallback(
|
|
typename TypedPrefChangeFunc<T>::Type aCallback,
|
|
const char (&aPref)[N],
|
|
T* 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 nsACString& aPref,
|
|
bool aDefault = false,
|
|
bool aSkipAssignment = false);
|
|
template<MemoryOrdering Order>
|
|
static nsresult AddAtomicBoolVarCache(Atomic<bool, Order>* aVariable,
|
|
const nsACString& aPref,
|
|
bool aDefault = false,
|
|
bool aSkipAssignment = false);
|
|
static nsresult AddIntVarCache(int32_t* aVariable,
|
|
const nsACString& aPref,
|
|
int32_t aDefault = 0,
|
|
bool aSkipAssignment = false);
|
|
template<MemoryOrdering Order>
|
|
static nsresult AddAtomicIntVarCache(Atomic<int32_t, Order>* aVariable,
|
|
const nsACString& aPref,
|
|
int32_t aDefault = 0,
|
|
bool aSkipAssignment = false);
|
|
static nsresult AddUintVarCache(uint32_t* aVariable,
|
|
const nsACString& aPref,
|
|
uint32_t aDefault = 0,
|
|
bool aSkipAssignment = false);
|
|
template<MemoryOrdering Order>
|
|
static nsresult AddAtomicUintVarCache(Atomic<uint32_t, Order>* aVariable,
|
|
const nsACString& aPref,
|
|
uint32_t aDefault = 0,
|
|
bool aSkipAssignment = false);
|
|
static nsresult AddFloatVarCache(float* aVariable,
|
|
const nsACString& aPref,
|
|
float aDefault = 0.0f,
|
|
bool aSkipAssignment = false);
|
|
|
|
template<int N>
|
|
static nsresult AddBoolVarCache(bool* aVariable,
|
|
const char (&aPref)[N],
|
|
bool aDefault = false,
|
|
bool aSkipAssignment = false)
|
|
{
|
|
return AddBoolVarCache(
|
|
aVariable, nsLiteralCString(aPref), aDefault, aSkipAssignment);
|
|
}
|
|
template<MemoryOrdering Order, int N>
|
|
static nsresult AddAtomicBoolVarCache(Atomic<bool, Order>* aVariable,
|
|
const char (&aPref)[N],
|
|
bool aDefault = false,
|
|
bool aSkipAssignment = false)
|
|
{
|
|
return AddAtomicBoolVarCache<Order>(
|
|
aVariable, nsLiteralCString(aPref), aDefault, aSkipAssignment);
|
|
}
|
|
template<int N>
|
|
static nsresult AddIntVarCache(int32_t* aVariable,
|
|
const char (&aPref)[N],
|
|
int32_t aDefault = 0,
|
|
bool aSkipAssignment = false)
|
|
{
|
|
return AddIntVarCache(
|
|
aVariable, nsLiteralCString(aPref), aDefault, aSkipAssignment);
|
|
}
|
|
template<MemoryOrdering Order, int N>
|
|
static nsresult AddAtomicIntVarCache(Atomic<int32_t, Order>* aVariable,
|
|
const char (&aPref)[N],
|
|
int32_t aDefault = 0,
|
|
bool aSkipAssignment = false)
|
|
{
|
|
return AddAtomicIntVarCache<Order>(
|
|
aVariable, nsLiteralCString(aPref), aDefault, aSkipAssignment);
|
|
}
|
|
template<int N>
|
|
static nsresult AddUintVarCache(uint32_t* aVariable,
|
|
const char (&aPref)[N],
|
|
uint32_t aDefault = 0,
|
|
bool aSkipAssignment = false)
|
|
{
|
|
return AddUintVarCache(
|
|
aVariable, nsLiteralCString(aPref), aDefault, aSkipAssignment);
|
|
}
|
|
template<MemoryOrdering Order, int N>
|
|
static nsresult AddAtomicUintVarCache(Atomic<uint32_t, Order>* aVariable,
|
|
const char (&aPref)[N],
|
|
uint32_t aDefault = 0,
|
|
bool aSkipAssignment = false)
|
|
{
|
|
return AddAtomicUintVarCache<Order>(
|
|
aVariable, nsLiteralCString(aPref), aDefault, aSkipAssignment);
|
|
}
|
|
template<int N>
|
|
static nsresult AddFloatVarCache(float* aVariable,
|
|
const char (&aPref)[N],
|
|
float aDefault = 0.0f,
|
|
bool aSkipAssignment = false)
|
|
{
|
|
return AddFloatVarCache(
|
|
aVariable, nsLiteralCString(aPref), aDefault, aSkipAssignment);
|
|
}
|
|
|
|
// 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);
|
|
|
|
static mozilla::ipc::FileDescriptor EnsureSnapshot(size_t* aSize);
|
|
static void InitSnapshot(const mozilla::ipc::FileDescriptor&, size_t aSize);
|
|
|
|
// 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 RegisterCallbacks(PrefChangedFunc aCallback,
|
|
const char** aPrefs,
|
|
void* aClosure,
|
|
MatchKind aMatchKind);
|
|
static nsresult UnregisterCallbacks(PrefChangedFunc aCallback,
|
|
const char** aPrefs,
|
|
void* aClosure,
|
|
MatchKind aMatchKind);
|
|
|
|
template<typename T>
|
|
static nsresult RegisterCallbackImpl(PrefChangedFunc aCallback,
|
|
T& aPref,
|
|
void* aClosure,
|
|
MatchKind aMatchKind,
|
|
bool aIsPriority = false);
|
|
template<typename T>
|
|
static nsresult UnregisterCallbackImpl(PrefChangedFunc aCallback,
|
|
T& 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
|