mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-21 01:05:45 +00:00
136f284c7d
Currently VarCache prefs are setup in two parts:
- The vanilla pref part, installed via a data file such as all.js, or via an
API call.
- The VarCache variable part, setup by an Add*VarCache() call.
Both parts are needed for the pref to actually operate as a proper VarCache
pref. (There are various prefs for which we do one but not the other unless a
certain condition is met.)
This patch introduces a new way of doing things. There is a new file,
modules/libpref/init/StaticPrefList.h, which defines prefs like this:
> VARCACHE_PREF(
> "layout.accessiblecaret.width",
> layout_accessiblecaret_width,
> float, 34.0
> )
This replaces both the existing parts.
The preprocessor is used to generate multiple things from this single
definition:
- A global variable (the VarCache itself).
- A getter for that global variable.
- A call to an init function that unconditionally installs the pref in the
prefs hash table at startup.
C++ files can include the new StaticPrefs.h file to access the getter.
Rust code cannot use the getter, but can access the global variable directly
via structs.rs. This is similar to how things currently work for Rust code.
Non-VarCache prefs can also be declared in StaticPrefList.h, using PREF instead
of the VARCACHE_PREF.
The new approach has the following advantages.
+ It eliminates the duplication (in all.js and the Add*VarCache() call) of the
pref name and default value, preventing potential mismatches. (This is a real
problem in practice!)
+ There is now a single initialization point for these VarCache prefs.
+ This avoids need to find a place to insert the Add*VarCache() calls, which
are currently spread all over the place.
+ It also eliminates the common pattern whereby these calls are wrapped in a
execute-once block protected by a static boolean (see bug 1346224).
+ It's no longer possible to have a VarCache pref for which only one of the
pieces has been setup.
+ It encapsulates the VarCache global variable, so there is no need to declare
it separately.
+ VarCache reads are done via a getter (e.g. StaticPrefs::foo_bar_baz())
instead of a raw global variable read.
+ This makes it clearer that you're reading a pref value, and easier to
search for uses.
+ This prevents accidental writes to the global variable.
+ This prevents accidental mistyping of the pref name.
+ This provides a single chokepoint in the code for such accesses, which make
adding checking and instrumentation feasible.
+ It subsumes MediaPrefs, and will allow that class to be removed. (gfxPrefs is
a harder lift, unfortunately.)
+ Once all VarCache prefs are migrated to the new approach, the VarCache
mechanism will be better encapsulated, with fewer details publicly visible.
+ (Future work) This will allow the pref names to be stored statically, saving
memory in every process.
The main downside of the new approach is that all of these prefs are in a
single header that is included in quite a few places, so any changes to this
header will cause a fair amount of recompilation.
Another minor downside is that all VarCache prefs are defined and visible from
start-up. For test-only prefs like network.predictor.doing-tests, having them
show in about:config isn't particularly useful.
The patch also moves three network VarCache prefs to the new mechanism as a
basic demonstration. (And note the inconsistencies in the multiple initial
values that were provided for
network.auth.subresource-img-cross-origin-http-auth-allow!) There will be
numerous follow-up bugs to convert the remaining VarCache prefs.
MozReview-Commit-ID: 9ABNpOR16uW
* * *
[mq]: fixup
MozReview-Commit-ID: 6ToT9dQjIAq
75 lines
2.2 KiB
C++
75 lines
2.2 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_StaticPrefs_h
|
|
#define mozilla_StaticPrefs_h
|
|
|
|
namespace mozilla {
|
|
|
|
// These typedefs are for use within StaticPrefList.h.
|
|
|
|
typedef const char* String;
|
|
|
|
typedef Atomic<bool, Relaxed> RelaxedAtomicBool;
|
|
typedef Atomic<bool, ReleaseAcquire> ReleaseAcquireAtomicBool;
|
|
typedef Atomic<bool, SequentiallyConsistent> SequentiallyConsistentAtomicBool;
|
|
|
|
typedef Atomic<int32_t, Relaxed> RelaxedAtomicInt32;
|
|
typedef Atomic<int32_t, ReleaseAcquire> ReleaseAcquireAtomicInt32;
|
|
typedef Atomic<int32_t, SequentiallyConsistent>
|
|
SequentiallyConsistentAtomicInt32;
|
|
|
|
typedef Atomic<uint32_t, Relaxed> RelaxedAtomicUint32;
|
|
typedef Atomic<uint32_t, ReleaseAcquire> ReleaseAcquireAtomicUint32;
|
|
typedef Atomic<uint32_t, SequentiallyConsistent>
|
|
SequentiallyConsistentAtomicUint32;
|
|
|
|
template<typename T>
|
|
struct StripAtomicImpl
|
|
{
|
|
typedef T Type;
|
|
};
|
|
|
|
template<typename T, MemoryOrdering Order>
|
|
struct StripAtomicImpl<Atomic<T, Order>>
|
|
{
|
|
typedef T Type;
|
|
};
|
|
|
|
template<typename T>
|
|
using StripAtomic = typename StripAtomicImpl<T>::Type;
|
|
|
|
class StaticPrefs
|
|
{
|
|
// For a VarCache pref like this:
|
|
//
|
|
// VARCACHE_PREF("my.varcache", my_varcache, int32_t, 99)
|
|
//
|
|
// we generate a static variable declaration and a getter definition:
|
|
//
|
|
// private:
|
|
// static int32_t sVarCache_my_varcache;
|
|
// public:
|
|
// static int32_t my_varcache() { return sVarCache_my_varcache; }
|
|
//
|
|
#define PREF(str, cpp_type, value)
|
|
#define VARCACHE_PREF(str, id, cpp_type, value) \
|
|
private: \
|
|
static cpp_type sVarCache_##id; \
|
|
public: \
|
|
static StripAtomic<cpp_type> id() { return sVarCache_##id; }
|
|
#include "mozilla/StaticPrefList.h"
|
|
#undef PREF
|
|
#undef VARCACHE_PREF
|
|
|
|
public:
|
|
static void InitAll(bool aIsStartup);
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_StaticPrefs_h
|