1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 #ifndef nsWrapperCache_h___
8 #define nsWrapperCache_h___
10 #include "nsCycleCollectionParticipant.h"
11 #include "mozilla/Assertions.h"
12 #include "mozilla/ServoUtils.h"
13 #include "mozilla/RustCell.h"
14 #include "js/HeapAPI.h"
15 #include "js/RootingAPI.h"
16 #include "js/TracingAPI.h"
17 #include "js/TypeDecls.h"
18 #include "nsISupports.h"
19 #include "nsISupportsUtils.h"
20 #include <type_traits>
22 namespace mozilla::dom
{
23 class ContentProcessMessageManager
;
24 class InProcessBrowserChildMessageManager
;
25 class BrowserChildMessageManager
;
26 } // namespace mozilla::dom
30 #define NS_WRAPPERCACHE_IID \
32 0x6f3179a1, 0x36f7, 0x4a5c, { \
33 0x8c, 0xf1, 0xad, 0xc8, 0x7c, 0xde, 0x3e, 0x87 \
37 // There are two sets of flags used by DOM nodes. One comes from reusing the
38 // remaining bits of the inherited nsWrapperCache flags (mFlags), and another is
39 // exclusive to nsINode (mBoolFlags).
41 // Both sets of flags are 32 bits. On 64-bit platforms, this can cause two
42 // wasted 32-bit fields due to alignment requirements. Some compilers are
43 // smart enough to coalesce the fields if we make mBoolFlags the first member
44 // of nsINode, but others (such as MSVC, but that's not officially supported
45 // by us anymore) are not. Also note that this kind of coalascing tends to
46 // interact poorly with rust's bindgen, see:
47 // https://github.com/rust-lang/rust-bindgen/issues/380
49 // So we just store mBoolFlags directly on nsWrapperCache on 64-bit platforms.
50 // This may waste space for some other nsWrapperCache-derived objects that have
51 // a 32-bit field as their first member, but those objects are unlikely to be as
52 // numerous or performance-critical as DOM nodes.
53 #ifdef HAVE_64BIT_BUILD
54 static_assert(sizeof(void*) == 8, "These architectures should be 64-bit");
55 # define BOOL_FLAGS_ON_WRAPPER_CACHE
57 static_assert(sizeof(void*) == 4, "Only support 32-bit and 64-bit");
61 * Class to store the wrapper for an object. This can only be used with objects
62 * that only have one non-security wrapper at a time (for an XPCWrappedNative
63 * this is usually ensured by setting an explicit parent in the PreCreate hook
66 * An instance of nsWrapperCache can be gotten from an object that implements
67 * a wrapper cache by calling QueryInterface on it. Note that this breaks XPCOM
68 * rules a bit (this object doesn't derive from nsISupports).
70 * The cache can store objects other than wrappers. We allow wrappers to use a
71 * separate JSObject to store their state (mostly expandos). If the wrapper is
72 * collected and we want to preserve this state we actually store the state
73 * object in the cache.
75 * The cache can store 3 types of objects: a DOM binding object (regular JS
76 * object or proxy), an nsOuterWindowProxy or an XPCWrappedNative wrapper.
78 * The finalizer for the wrapper clears the cache.
80 * A compacting GC can move the wrapper object. Pointers to moved objects are
81 * usually found and updated by tracing the heap, however non-preserved wrappers
82 * are weak references and are not traced, so another approach is
83 * necessary. Instead a class hook (objectMovedOp) is provided that is called
84 * when an object is moved and is responsible for ensuring pointers are
85 * updated. It does this by calling UpdateWrapper() on the wrapper
86 * cache. SetWrapper() asserts that the hook is implemented for any wrapper set.
88 * A number of the methods are implemented in nsWrapperCacheInlines.h because we
89 * have to include some JS headers that don't play nicely with the rest of the
90 * codebase. Include nsWrapperCacheInlines.h if you need to call those methods.
93 class JS_HAZ_ROOTED nsWrapperCache
{
95 NS_DECLARE_STATIC_IID_ACCESSOR(NS_WRAPPERCACHE_IID
)
97 nsWrapperCache() = default;
99 // Preserved wrappers should never end up getting cleared, but this can
100 // happen during shutdown when a leaked wrapper object is finalized, causing
101 // its wrapper to be cleared.
102 MOZ_ASSERT(!PreservingWrapper() || js::RuntimeIsBeingDestroyed(),
103 "Destroying cache with a preserved wrapper!");
107 * Get the cached wrapper.
109 * This getter clears the gray bit before handing out the JSObject which means
110 * that the object is guaranteed to be kept alive past the next CC.
112 JSObject
* GetWrapper() const;
115 * Get the cached wrapper.
117 * This getter does not change the color of the JSObject meaning that the
118 * object returned is not guaranteed to be kept alive past the next CC.
120 * This should only be called if you are certain that the return value won't
121 * be passed into a JSAPI function and that it won't be stored without being
122 * rooted (or otherwise signaling the stored value to the CC).
124 JSObject
* GetWrapperPreserveColor() const;
127 * Get the cached wrapper.
129 * This getter does not check whether the wrapper is dead and in the process
130 * of being finalized.
132 * This should only be called if you really need to see the raw contents of
133 * this cache, for example as part of finalization. Don't store the result
134 * anywhere or pass it into JSAPI functions that may cause the value to
137 JSObject
* GetWrapperMaybeDead() const { return mWrapper
; }
141 static bool HasJSObjectMovedOp(JSObject
* aWrapper
);
143 static void AssertUpdatedWrapperZone(const JSObject
* aNewObject
,
144 const JSObject
* aOldObject
);
149 void SetWrapper(JSObject
* aWrapper
) {
150 MOZ_ASSERT(!PreservingWrapper(), "Clearing a preserved wrapper!");
151 MOZ_ASSERT(aWrapper
, "Use ClearWrapper!");
152 MOZ_ASSERT(HasJSObjectMovedOp(aWrapper
),
153 "Object has not provided the hook to update the wrapper if it "
156 SetWrapperJSObject(aWrapper
);
162 void ClearWrapper() {
163 // Preserved wrappers should never end up getting cleared, but this can
164 // happen during shutdown when a leaked wrapper object is finalized, causing
165 // its wrapper to be cleared.
166 MOZ_ASSERT(!PreservingWrapper() || js::RuntimeIsBeingDestroyed(),
167 "Clearing a preserved wrapper!");
168 SetWrapperJSObject(nullptr);
172 * Clear the cache if it still contains a specific wrapper object. This should
173 * be called from the finalizer for the wrapper.
175 void ClearWrapper(JSObject
* obj
) {
176 if (obj
== mWrapper
) {
182 * Update the wrapper when the object moves between globals.
184 template <typename T
>
185 void UpdateWrapperForNewGlobal(T
* aScriptObjectHolder
, JSObject
* aNewWrapper
);
188 * Update the wrapper if the object it contains is moved.
190 * This method must be called from the objectMovedOp class extension hook for
191 * any wrapper cached object.
193 void UpdateWrapper(JSObject
* aNewObject
, const JSObject
* aOldObject
) {
195 AssertUpdatedWrapperZone(aNewObject
, aOldObject
);
198 MOZ_ASSERT(mWrapper
== aOldObject
);
199 mWrapper
= aNewObject
;
200 if (PreservingWrapper() && !JS::ObjectIsTenured(mWrapper
)) {
201 // Can pass prevp as null here since a previous store buffer entry has
202 // been cleared by the current nursery collection.
203 JS::HeapObjectPostWriteBarrier(&mWrapper
, nullptr, mWrapper
);
208 bool PreservingWrapper() const {
209 return HasWrapperFlag(WRAPPER_BIT_PRESERVED
);
213 * Wrap the object corresponding to this wrapper cache. If non-null is
214 * returned, the object has already been stored in the wrapper cache.
216 virtual JSObject
* WrapObject(JSContext
* cx
,
217 JS::Handle
<JSObject
*> aGivenProto
) = 0;
220 * Returns true if the object has a wrapper that is known live from the point
221 * of view of cycle collection.
223 bool HasKnownLiveWrapper() const;
226 * Returns true if the object has a known-live wrapper (from the CC point of
227 * view) and all the GC things it is keeping alive are already known-live from
228 * CC's point of view.
230 bool HasKnownLiveWrapperAndDoesNotNeedTracing(nsISupports
* aThis
);
232 bool HasNothingToTrace(nsISupports
* aThis
);
235 * Mark our wrapper, if any, as live as far as the CC is concerned.
237 void MarkWrapperLive();
239 // Only meant to be called by code that preserves a wrapper.
240 void SetPreservingWrapper(bool aPreserve
) {
242 SetWrapperFlags(WRAPPER_BIT_PRESERVED
);
244 UnsetWrapperFlags(WRAPPER_BIT_PRESERVED
);
248 void TraceWrapper(const TraceCallbacks
& aCallbacks
, void* aClosure
) {
249 if (PreservingWrapper() && mWrapper
) {
250 aCallbacks
.Trace(this, "Preserved wrapper", aClosure
);
255 * The following methods for getting and manipulating flags allow the unused
256 * bits of mFlags to be used by derived classes.
259 using FlagsType
= uint32_t;
261 FlagsType
GetFlags() const {
262 MOZ_ASSERT(NS_IsMainThread());
263 MOZ_ASSERT(!mozilla::IsInServoTraversal());
264 return mFlags
.Get() & ~kWrapperFlagsMask
;
267 // This can be called from stylo threads too, so it needs to be atomic, as
268 // this value may be mutated from multiple threads during servo traversal from
270 bool HasFlag(FlagsType aFlag
) const {
271 MOZ_ASSERT((aFlag
& kWrapperFlagsMask
) == 0, "Bad flag mask");
272 return __atomic_load_n(mFlags
.AsPtr(), __ATOMIC_RELAXED
) & aFlag
;
275 // Identical to HasFlag, but more explicit about its handling of multiple
276 // flags. This can be called from stylo threads too.
277 bool HasAnyOfFlags(FlagsType aFlags
) const { return HasFlag(aFlags
); }
279 // This can also be called from stylo, in the sequential part of the
280 // traversal, though it's probably not worth differentiating them for the
281 // purposes of assertions.
282 bool HasAllFlags(FlagsType aFlags
) const {
283 MOZ_ASSERT((aFlags
& kWrapperFlagsMask
) == 0, "Bad flag mask");
284 return (__atomic_load_n(mFlags
.AsPtr(), __ATOMIC_RELAXED
) & aFlags
) ==
288 void SetFlags(FlagsType aFlagsToSet
) {
289 MOZ_ASSERT(NS_IsMainThread());
290 MOZ_ASSERT((aFlagsToSet
& kWrapperFlagsMask
) == 0, "Bad flag mask");
291 mFlags
.Set(mFlags
.Get() | aFlagsToSet
);
294 void UnsetFlags(FlagsType aFlagsToUnset
) {
295 MOZ_ASSERT(NS_IsMainThread());
296 MOZ_ASSERT((aFlagsToUnset
& kWrapperFlagsMask
) == 0, "Bad flag mask");
297 mFlags
.Set(mFlags
.Get() & ~aFlagsToUnset
);
300 void PreserveWrapper(nsISupports
* aScriptObjectHolder
) {
301 if (PreservingWrapper()) {
305 nsISupports
* ccISupports
;
306 aScriptObjectHolder
->QueryInterface(NS_GET_IID(nsCycleCollectionISupports
),
307 reinterpret_cast<void**>(&ccISupports
));
308 MOZ_ASSERT(ccISupports
);
310 nsXPCOMCycleCollectionParticipant
* participant
;
311 CallQueryInterface(ccISupports
, &participant
);
312 PreserveWrapper(ccISupports
, participant
);
315 void PreserveWrapper(void* aScriptObjectHolder
,
316 nsScriptObjectTracer
* aTracer
) {
317 if (PreservingWrapper()) {
321 JSObject
* wrapper
= GetWrapper(); // Read barrier for incremental GC.
322 HoldJSObjects(aScriptObjectHolder
, aTracer
, JS::GetObjectZone(wrapper
));
323 SetPreservingWrapper(true);
325 // Make sure the cycle collector will be able to traverse to the wrapper.
326 CheckCCWrapperTraversal(aScriptObjectHolder
, aTracer
);
330 void ReleaseWrapper(void* aScriptObjectHolder
);
332 void TraceWrapper(JSTracer
* aTrc
, const char* name
) {
334 js::UnsafeTraceManuallyBarrieredEdge(aTrc
, &mWrapper
, name
);
339 void PoisonWrapper() {
341 // Set the pointer to a value that will cause a crash if it is
343 mWrapper
= reinterpret_cast<JSObject
*>(1);
348 void SetWrapperJSObject(JSObject
* aWrapper
);
350 // We'd like to assert that these aren't used from servo threads, but we don't
351 // have a great way to do that because:
352 // * We can't just assert that they get used on the main thread, because
353 // these are used from workers.
354 // * We can't just assert that they aren't used when IsInServoTraversal(),
355 // because the traversal has a sequential, main-thread-only phase, where we
356 // run animations that can fiddle with JS promises.
357 FlagsType
GetWrapperFlags() const { return mFlags
.Get() & kWrapperFlagsMask
; }
359 bool HasWrapperFlag(FlagsType aFlag
) const {
360 MOZ_ASSERT((aFlag
& ~kWrapperFlagsMask
) == 0, "Bad wrapper flag bits");
361 return !!(mFlags
.Get() & aFlag
);
364 void SetWrapperFlags(FlagsType aFlagsToSet
) {
365 MOZ_ASSERT((aFlagsToSet
& ~kWrapperFlagsMask
) == 0,
366 "Bad wrapper flag bits");
367 mFlags
.Set(mFlags
.Get() | aFlagsToSet
);
370 void UnsetWrapperFlags(FlagsType aFlagsToUnset
) {
371 MOZ_ASSERT((aFlagsToUnset
& ~kWrapperFlagsMask
) == 0,
372 "Bad wrapper flag bits");
373 mFlags
.Set(mFlags
.Get() & ~aFlagsToUnset
);
376 void HoldJSObjects(void* aScriptObjectHolder
, nsScriptObjectTracer
* aTracer
,
381 void CheckCCWrapperTraversal(void* aScriptObjectHolder
,
382 nsScriptObjectTracer
* aTracer
);
388 * If this bit is set then we're preserving the wrapper, which in effect ties
389 * the lifetime of the JS object stored in the cache to the lifetime of the
390 * native object. We rely on the cycle collector to break the cycle that this
391 * causes between the native object and the JS object, so it is important that
392 * any native object that supports preserving of its wrapper
393 * traces/traverses/unlinks the cached JS object (see
394 * NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER and
395 * NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER).
397 enum { WRAPPER_BIT_PRESERVED
= 1 << 0 };
399 enum { kWrapperFlagsMask
= WRAPPER_BIT_PRESERVED
};
401 JSObject
* mWrapper
= nullptr;
403 // Rust code needs to read and write some flags atomically, but we don't want
404 // to make the wrapper flags atomic whole-sale because main-thread code would
405 // become more expensive (loads wouldn't change, but flag setting /
406 // unsetting could become slower enough to be noticeable). Making this an
407 // Atomic whole-sale needs more measuring.
409 // In order to not mess with aliasing rules the type should not be frozen, so
410 // we use a RustCell, which contains an UnsafeCell internally. See also the
411 // handling of ServoData (though that's a bit different).
412 mozilla::RustCell
<FlagsType
> mFlags
{0};
415 #ifdef BOOL_FLAGS_ON_WRAPPER_CACHE
416 uint32_t mBoolFlags
= 0;
420 enum { WRAPPER_CACHE_FLAGS_BITS_USED
= 1 };
422 NS_DEFINE_STATIC_IID_ACCESSOR(nsWrapperCache
, NS_WRAPPERCACHE_IID
)
424 #define NS_WRAPPERCACHE_INTERFACE_TABLE_ENTRY \
425 if (aIID.Equals(NS_GET_IID(nsWrapperCache))) { \
426 *aInstancePtr = static_cast<nsWrapperCache*>(this); \
430 #define NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY \
431 NS_WRAPPERCACHE_INTERFACE_TABLE_ENTRY \
434 // Cycle collector macros for wrapper caches.
436 // The NS_DECL_*WRAPPERCACHE_* macros make it easier to mark classes as holding
437 // just a single pointer to a JS value. That information is then used for
438 // certain GC optimizations.
440 #define NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS_AMBIGUOUS(_class, _base) \
441 class NS_CYCLE_COLLECTION_INNERCLASS \
442 : public nsXPCOMCycleCollectionParticipant { \
444 constexpr explicit NS_CYCLE_COLLECTION_INNERCLASS(Flags aFlags = 0) \
445 : nsXPCOMCycleCollectionParticipant(aFlags | \
446 FlagMaybeSingleZoneJSHolder) {} \
449 NS_DECL_CYCLE_COLLECTION_CLASS_BODY(_class, _base) \
451 Trace(void* p, const TraceCallbacks& cb, void* closure) override; \
453 TraceWrapper(void* aPtr, const TraceCallbacks& aCb, void* aClosure) final; \
454 NS_IMPL_GET_XPCOM_CYCLE_COLLECTION_PARTICIPANT(_class) \
456 NS_CHECK_FOR_RIGHT_PARTICIPANT_IMPL(_class) \
457 static NS_CYCLE_COLLECTION_INNERCLASS NS_CYCLE_COLLECTION_INNERNAME; \
458 NOT_INHERITED_CANT_OVERRIDE
460 #define NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(_class) \
461 NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS_AMBIGUOUS(_class, _class)
463 #define NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS_INHERITED(_class, \
465 class NS_CYCLE_COLLECTION_INNERCLASS \
466 : public NS_CYCLE_COLLECTION_CLASSNAME(_base_class) { \
468 constexpr explicit NS_CYCLE_COLLECTION_INNERCLASS(Flags aFlags) \
469 : NS_CYCLE_COLLECTION_CLASSNAME(_base_class)( \
470 aFlags | FlagMaybeSingleZoneJSHolder) {} \
473 NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_BODY(_class, _base_class) \
475 Trace(void* p, const TraceCallbacks& cb, void* closure) override; \
477 TraceWrapper(void* aPtr, const TraceCallbacks& aCb, void* aClosure) final; \
478 NS_IMPL_GET_XPCOM_CYCLE_COLLECTION_PARTICIPANT(_class) \
480 NS_CHECK_FOR_RIGHT_PARTICIPANT_IMPL_INHERITED(_class) \
481 static NS_CYCLE_COLLECTION_INNERCLASS NS_CYCLE_COLLECTION_INNERNAME;
483 #define NS_DECL_CYCLE_COLLECTION_SKIPPABLE_WRAPPERCACHE_CLASS_AMBIGUOUS( \
485 class NS_CYCLE_COLLECTION_INNERCLASS \
486 : public nsXPCOMCycleCollectionParticipant { \
488 constexpr explicit NS_CYCLE_COLLECTION_INNERCLASS(Flags aFlags) \
489 : nsXPCOMCycleCollectionParticipant(aFlags | FlagMightSkip | \
490 FlagMaybeSingleZoneJSHolder) {} \
493 NS_DECL_CYCLE_COLLECTION_CLASS_BODY(_class, _base) \
495 Trace(void* p, const TraceCallbacks& cb, void* closure) override; \
497 TraceWrapper(void* aPtr, const TraceCallbacks& aCb, void* aClosure) final; \
498 NS_IMETHOD_(bool) CanSkipReal(void* p, bool aRemovingAllowed) override; \
499 NS_IMETHOD_(bool) CanSkipInCCReal(void* p) override; \
500 NS_IMETHOD_(bool) CanSkipThisReal(void* p) override; \
501 NS_IMPL_GET_XPCOM_CYCLE_COLLECTION_PARTICIPANT(_class) \
503 NS_CHECK_FOR_RIGHT_PARTICIPANT_IMPL(_class) \
504 static NS_CYCLE_COLLECTION_INNERCLASS NS_CYCLE_COLLECTION_INNERNAME; \
505 NOT_INHERITED_CANT_OVERRIDE
507 #define NS_DECL_CYCLE_COLLECTION_SKIPPABLE_WRAPPERCACHE_CLASS(_class) \
508 NS_DECL_CYCLE_COLLECTION_SKIPPABLE_WRAPPERCACHE_CLASS_AMBIGUOUS(_class, \
511 #define NS_DECL_CYCLE_COLLECTION_SKIPPABLE_WRAPPERCACHE_CLASS_INHERITED( \
512 _class, _base_class) \
513 class NS_CYCLE_COLLECTION_INNERCLASS \
514 : public NS_CYCLE_COLLECTION_CLASSNAME(_base_class) { \
516 constexpr explicit NS_CYCLE_COLLECTION_INNERCLASS(Flags aFlags = 0) \
517 : NS_CYCLE_COLLECTION_CLASSNAME(_base_class)( \
518 aFlags | FlagMightSkip | FlagMaybeSingleZoneJSHolder) {} \
521 NS_DECL_CYCLE_COLLECTION_CLASS_BODY(_class, _base_class) \
523 Trace(void* p, const TraceCallbacks& cb, void* closure) override; \
525 TraceWrapper(void* aPtr, const TraceCallbacks& aCb, void* aClosure) final; \
526 NS_IMETHOD_(bool) CanSkipReal(void* p, bool aRemovingAllowed) override; \
527 NS_IMETHOD_(bool) CanSkipInCCReal(void* p) override; \
528 NS_IMETHOD_(bool) CanSkipThisReal(void* p) override; \
529 NS_IMPL_GET_XPCOM_CYCLE_COLLECTION_PARTICIPANT(_class) \
531 NS_CHECK_FOR_RIGHT_PARTICIPANT_IMPL_INHERITED(_class) \
532 static NS_CYCLE_COLLECTION_INNERCLASS NS_CYCLE_COLLECTION_INNERNAME;
534 #define NS_DECL_CYCLE_COLLECTION_NATIVE_WRAPPERCACHE_CLASS(_class) \
535 void DeleteCycleCollectable(void) { delete this; } \
536 class NS_CYCLE_COLLECTION_INNERCLASS : public nsScriptObjectTracer { \
538 constexpr explicit NS_CYCLE_COLLECTION_INNERCLASS(Flags aFlags = 0) \
539 : nsScriptObjectTracer(aFlags | FlagMaybeSingleZoneJSHolder) {} \
542 NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS_BODY(_class) \
544 Trace(void* p, const TraceCallbacks& cb, void* closure) override; \
546 TraceWrapper(void* aPtr, const TraceCallbacks& aCb, void* aClosure) final; \
547 static constexpr nsScriptObjectTracer* GetParticipant() { \
548 return &_class::NS_CYCLE_COLLECTION_INNERNAME; \
551 static NS_CYCLE_COLLECTION_INNERCLASS NS_CYCLE_COLLECTION_INNERNAME;
553 #define NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER \
554 tmp->TraceWrapper(aCallbacks, aClosure);
556 #define NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER \
557 tmp->ReleaseWrapper(p);
559 #define NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(_class) \
560 static_assert(std::is_base_of<nsWrapperCache, _class>::value, \
561 "Class should inherit nsWrapperCache"); \
562 NS_IMPL_CYCLE_COLLECTION_SINGLE_ZONE_SCRIPT_HOLDER_CLASS(_class) \
563 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(_class) \
564 TraceWrapper(p, aCallbacks, aClosure); \
565 NS_IMPL_CYCLE_COLLECTION_TRACE_END \
566 void NS_CYCLE_COLLECTION_CLASSNAME(_class)::TraceWrapper( \
567 void* p, const TraceCallbacks& aCallbacks, void* aClosure) { \
568 _class* tmp = DowncastCCParticipant<_class>(p); \
569 NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER \
572 #define NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(_class) \
573 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(_class) \
574 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class) \
575 NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER \
576 NS_IMPL_CYCLE_COLLECTION_UNLINK_END \
577 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class) \
578 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
580 #define NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(_class, ...) \
581 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(_class) \
582 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class) \
583 NS_IMPL_CYCLE_COLLECTION_UNLINK(__VA_ARGS__) \
584 NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER \
585 NS_IMPL_CYCLE_COLLECTION_UNLINK_END \
586 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class) \
587 NS_IMPL_CYCLE_COLLECTION_TRAVERSE(__VA_ARGS__) \
588 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
590 #define NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WEAK(_class, ...) \
591 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(_class) \
592 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class) \
593 NS_IMPL_CYCLE_COLLECTION_UNLINK(__VA_ARGS__) \
594 NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER \
595 NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_REFERENCE \
596 NS_IMPL_CYCLE_COLLECTION_UNLINK_END \
597 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class) \
598 NS_IMPL_CYCLE_COLLECTION_TRAVERSE(__VA_ARGS__) \
599 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
601 #define NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WEAK_PTR(_class, ...) \
602 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(_class) \
603 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class) \
604 NS_IMPL_CYCLE_COLLECTION_UNLINK(__VA_ARGS__) \
605 NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER \
606 NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_PTR \
607 NS_IMPL_CYCLE_COLLECTION_UNLINK_END \
608 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class) \
609 NS_IMPL_CYCLE_COLLECTION_TRAVERSE(__VA_ARGS__) \
610 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
612 // This is used for wrapper cached classes that inherit from cycle
613 // collected non-wrapper cached classes.
614 #define NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_INHERITED(_class, _base, ...) \
615 static_assert(!std::is_base_of<nsWrapperCache, _base>::value, \
616 "Base class should not inherit nsWrapperCache"); \
617 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(_class) \
618 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(_class, _base) \
619 NS_IMPL_CYCLE_COLLECTION_UNLINK(__VA_ARGS__) \
620 NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER \
621 NS_IMPL_CYCLE_COLLECTION_UNLINK_END \
622 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(_class, _base) \
623 /* Assert somewhere, in this case in the traverse method, that the */ \
624 /* parent isn't a single zone holder*/ \
625 MOZ_ASSERT(!_base::NS_CYCLE_COLLECTION_INNERNAME.IsSingleZoneJSHolder()); \
626 NS_IMPL_CYCLE_COLLECTION_TRAVERSE(__VA_ARGS__) \
627 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
629 // if NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WITH_JS_MEMBERS is used to implement
630 // a wrappercache class, one needs to use
631 // NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS and its variants in the class
633 #define NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WITH_JS_MEMBERS( \
634 class_, native_members_, js_members_) \
635 static_assert(std::is_base_of<nsWrapperCache, class_>::value, \
636 "Class should inherit nsWrapperCache"); \
637 NS_IMPL_CYCLE_COLLECTION_CLASS(class_) \
638 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(class_) \
639 using ::ImplCycleCollectionUnlink; \
640 NS_IMPL_CYCLE_COLLECTION_UNLINK( \
641 MOZ_FOR_EACH_EXPAND_HELPER native_members_) \
642 NS_IMPL_CYCLE_COLLECTION_UNLINK(MOZ_FOR_EACH_EXPAND_HELPER js_members_) \
643 NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER \
644 NS_IMPL_CYCLE_COLLECTION_UNLINK_END \
645 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(class_) \
646 NS_IMPL_CYCLE_COLLECTION_TRAVERSE( \
647 MOZ_FOR_EACH_EXPAND_HELPER native_members_) \
648 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END \
649 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(class_) \
650 NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBERS( \
651 MOZ_FOR_EACH_EXPAND_HELPER js_members_) \
652 NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER \
653 NS_IMPL_CYCLE_COLLECTION_TRACE_END
655 #endif /* nsWrapperCache_h___ */