1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
|
/* -*- 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/. */
// Documentation for libpref is in modules/libpref/docs/index.rst.
#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/MozPromise.h"
#include "mozilla/StaticPtr.h"
#include "nsCOMPtr.h"
#include "nsIObserver.h"
#include "nsIPrefBranch.h"
#include "nsIPrefService.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsWeakReference.h"
#include "nsXULAppAPI.h"
#include <atomic>
#include <functional>
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 {
struct RegisterCallbacksInternal;
void UnloadPrefsModule();
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:
using WritePrefFilePromise = MozPromise<bool, nsresult, false>;
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();
static void FinishInitializingUserPrefs();
// 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);
static int32_t GetInt(const char* aPrefName, int32_t aFallback = 0,
PrefValueKind aKind = PrefValueKind::User);
static uint32_t GetUint(const char* aPrefName, uint32_t aFallback = 0,
PrefValueKind aKind = PrefValueKind::User);
static float GetFloat(const char* aPrefName, float aFallback = 0.0f,
PrefValueKind aKind = PrefValueKind::User);
// 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) {
nsAutoCString value;
value.AppendFloat(aValue);
return SetCString(aPrefName, value, 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);
static bool IsSanitized(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);
// Whether the pref has a user value or not.
static bool HasDefaultValue(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* const* aPrefs);
static nsresult AddWeakObservers(nsIObserver* aObserver,
const char* const* aPrefs);
static nsresult RemoveObservers(nsIObserver* aObserver,
const char* const* aPrefs);
// Registers/Unregisters the callback function for the aPref.
template <typename T = void>
static nsresult RegisterCallback(PrefChangedFunc aCallback,
const nsACString& aPref,
T* aClosure = nullptr) {
return RegisterCallback(aCallback, aPref, aClosure, ExactMatch);
}
template <typename T = void>
static nsresult UnregisterCallback(PrefChangedFunc 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(PrefChangedFunc 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(PrefChangedFunc 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(PrefChangedFunc 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(PrefChangedFunc 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(PrefChangedFunc aCallback,
const char* const* aPrefs,
T* aClosure = nullptr) {
return RegisterCallbacks(aCallback, aPrefs, aClosure, ExactMatch);
}
static nsresult RegisterCallbacksAndCall(PrefChangedFunc aCallback,
const char* const* aPrefs,
void* aClosure = nullptr);
template <typename T = void>
static nsresult UnregisterCallbacks(PrefChangedFunc aCallback,
const char* const* aPrefs,
T* aClosure = nullptr) {
return UnregisterCallbacks(aCallback, aPrefs, aClosure, ExactMatch);
}
template <typename T = void>
static nsresult RegisterPrefixCallbacks(PrefChangedFunc aCallback,
const char* const* aPrefs,
T* aClosure = nullptr) {
return RegisterCallbacks(aCallback, aPrefs, aClosure, PrefixMatch);
}
template <typename T = void>
static nsresult UnregisterPrefixCallbacks(PrefChangedFunc aCallback,
const char* const* aPrefs,
T* aClosure = nullptr) {
return UnregisterCallbacks(aCallback, aPrefs, aClosure, PrefixMatch);
}
template <int N, typename T = void>
static nsresult RegisterCallback(PrefChangedFunc aCallback,
const char (&aPref)[N],
T* aClosure = nullptr) {
return RegisterCallback(aCallback, nsLiteralCString(aPref), aClosure,
ExactMatch);
}
template <int N, typename T = void>
static nsresult UnregisterCallback(PrefChangedFunc aCallback,
const char (&aPref)[N],
T* aClosure = nullptr) {
return UnregisterCallback(aCallback, nsLiteralCString(aPref), aClosure,
ExactMatch);
}
template <int N, typename T = void>
static nsresult RegisterCallbackAndCall(PrefChangedFunc aCallback,
const char (&aPref)[N],
T* aClosure = nullptr) {
return RegisterCallbackAndCall(aCallback, nsLiteralCString(aPref), aClosure,
ExactMatch);
}
template <int N, typename T = void>
static nsresult RegisterPrefixCallback(PrefChangedFunc aCallback,
const char (&aPref)[N],
T* aClosure = nullptr) {
return RegisterCallback(aCallback, nsLiteralCString(aPref), aClosure,
PrefixMatch);
}
template <int N, typename T = void>
static nsresult RegisterPrefixCallbackAndCall(PrefChangedFunc aCallback,
const char (&aPref)[N],
T* aClosure = nullptr) {
return RegisterCallbackAndCall(aCallback, nsLiteralCString(aPref), aClosure,
PrefixMatch);
}
template <int N, typename T = void>
static nsresult UnregisterPrefixCallback(PrefChangedFunc aCallback,
const char (&aPref)[N],
T* aClosure = nullptr) {
return UnregisterCallback(aCallback, nsLiteralCString(aPref), aClosure,
PrefixMatch);
}
// 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,
bool aIsDestinationWebContentProcess);
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,
const GeckoProcessType aDestinationProcessType,
const nsACString& aDestinationRemoteType);
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();
// If this is false, only blocking writes, on main thread are allowed.
bool AllowOffMainThreadSave();
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,
UniquePtr<MozPromiseHolder<WritePrefFilePromise>> aPromise = nullptr);
nsresult ResetUserPrefs();
// 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 nsresult InitInitialObjects(bool aIsStartup);
friend struct Internals;
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* const* aPrefs, void* aClosure,
MatchKind aMatchKind);
static nsresult UnregisterCallbacks(PrefChangedFunc aCallback,
const char* const* 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();
};
extern Atomic<bool, Relaxed> sOmitBlocklistedPrefValues;
extern Atomic<bool, Relaxed> sCrashOnBlocklistedPref;
bool IsPreferenceSanitized(const char* aPref);
const char kFissionEnforceBlockList[] =
"fission.enforceBlocklistedPrefsInSubprocesses";
const char kFissionOmitBlockListValues[] =
"fission.omitBlocklistedPrefsInSubprocesses";
void OnFissionBlocklistPrefChange(const char* aPref, void* aData);
} // namespace mozilla
#endif // mozilla_Preferences_h
|