xpcom/glue/nsCycleCollectionParticipant.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * The Mozilla Foundation.
  19  * Portions created by the Initial Developer are Copyright (C) 2006
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either of the GNU General Public License Version 2 or later (the "GPL"),
  26  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 #ifndef nsCycleCollectionParticipant_h__
  39 #define nsCycleCollectionParticipant_h__
  40
  41 #include "nsISupports.h"
  42
  43 // NOTE: If you use header files to define DEBUG_CC, you must do so here
  44 // *and* in nsCycleCollector.h
  45 //#define DEBUG_CC
  46
  47 #define NS_CYCLECOLLECTIONPARTICIPANT_IID                                      \
  48 {                                                                              \
  49     0x9674489b,                                                                \
  50     0x1f6f,                                                                    \
  51     0x4550,                                                                    \
  52     { 0xa7, 0x30, 0xcc, 0xae, 0xdd, 0x10, 0x4c, 0xf9 }                         \
  53 }
  54
  55 /**
  56  * Special IID to get at the base nsISupports for a class. Usually this is the
  57  * canonical nsISupports pointer, but in the case of tearoffs for example it is
  58  * the base nsISupports pointer of the tearoff. This allow the cycle collector
  59  * to have separate nsCycleCollectionParticipant's for tearoffs or aggregated
  60  * classes.
  61  */
  62 #define NS_CYCLECOLLECTIONISUPPORTS_IID                                        \
  63 {                                                                              \
  64     0xc61eac14,                                                                \
  65     0x5f7a,                                                                    \
  66     0x4481,                                                                    \
  67     { 0x96, 0x5e, 0x7e, 0xaa, 0x6e, 0xff, 0xa8, 0x5f }                         \
  68 }
  69
  70 /**
  71  * Just holds the IID so NS_GET_IID works.
  72  */
  73 class nsCycleCollectionISupports
  74 {
  75 public:
  76     NS_DECLARE_STATIC_IID_ACCESSOR(NS_CYCLECOLLECTIONISUPPORTS_IID)
  77 };
  78
  79 NS_DEFINE_STATIC_IID_ACCESSOR(nsCycleCollectionISupports,
  80                               NS_CYCLECOLLECTIONISUPPORTS_IID)
  81
  82 class nsCycleCollectionParticipant;
  83
  84 enum CCNodeType { RefCounted, GCMarked, GCUnmarked };
  85
  86 class NS_NO_VTABLE nsCycleCollectionTraversalCallback
  87 {
  88 public:
  89     // If type is RefCounted you must call DescribeNode() with an accurate
  90     // refcount, otherwise cycle collection will fail, and probably crash.
  91     // If type is not refcounted then the refcount will be ignored.
  92     // If the callback cares about objsz or objname, it should
  93     // put WANT_DEBUG_INFO in mFlags.
  94     NS_IMETHOD_(void) DescribeNode(CCNodeType type,
  95                                    nsrefcnt refcount,
  96                                    size_t objsz,
  97                                    const char *objname) = 0;
  98     NS_IMETHOD_(void) NoteXPCOMRoot(nsISupports *root) = 0;
  99     NS_IMETHOD_(void) NoteRoot(PRUint32 langID, void *root,
 100                                nsCycleCollectionParticipant* helper) = 0;
 101     NS_IMETHOD_(void) NoteScriptChild(PRUint32 langID, void *child) = 0;
 102     NS_IMETHOD_(void) NoteXPCOMChild(nsISupports *child) = 0;
 103     NS_IMETHOD_(void) NoteNativeChild(void *child,
 104                                       nsCycleCollectionParticipant *helper) = 0;
 105
 106     // Give a name to the edge associated with the next call to
 107     // NoteScriptChild, NoteXPCOMChild, or NoteNativeChild.
 108     // Callbacks who care about this should set WANT_DEBUG_INFO in the
 109     // flags.
 110     NS_IMETHOD_(void) NoteNextEdgeName(const char* name) = 0;
 111
 112     enum {
 113         // Values for flags:
 114
 115         // Caller should pass useful objsz and objname to DescribeNode
 116         // and should call NoteNextEdgeName.
 117         WANT_DEBUG_INFO = (1<<0),
 118
 119         // Caller should not skip objects that we know will be
 120         // uncollectable.
 121         WANT_ALL_TRACES = (1<<1)
 122     };
 123     PRUint32 Flags() const { return mFlags; }
 124     PRBool WantDebugInfo() const { return (mFlags & WANT_DEBUG_INFO) != 0; }
 125     PRBool WantAllTraces() const { return (mFlags & WANT_ALL_TRACES) != 0; }
 126 protected:
 127     nsCycleCollectionTraversalCallback() : mFlags(0) {}
 128
 129     PRUint32 mFlags;
 130 };
 131
 132 class NS_NO_VTABLE nsCycleCollectionParticipant
 133 {
 134 public:
 135     NS_DECLARE_STATIC_IID_ACCESSOR(NS_CYCLECOLLECTIONPARTICIPANT_IID)
 136
 137     NS_IMETHOD Traverse(void *p, nsCycleCollectionTraversalCallback &cb) = 0;
 138
 139     NS_IMETHOD RootAndUnlinkJSObjects(void *p) = 0;
 140     NS_IMETHOD Unlink(void *p) = 0;
 141     NS_IMETHOD Unroot(void *p) = 0;
 142 };
 143
 144 NS_DEFINE_STATIC_IID_ACCESSOR(nsCycleCollectionParticipant,
 145                               NS_CYCLECOLLECTIONPARTICIPANT_IID)
 146
 147 #undef IMETHOD_VISIBILITY
 148 #define IMETHOD_VISIBILITY NS_COM_GLUE
 149
 150 typedef void
 151 (* TraceCallback)(PRUint32 langID, void *p, void *closure);
 152
 153 class NS_NO_VTABLE nsScriptObjectTracer : public nsCycleCollectionParticipant
 154 {
 155 public:
 156     NS_IMETHOD_(void) Trace(void *p, TraceCallback cb, void *closure) = 0;
 157     void NS_COM_GLUE TraverseScriptObjects(void *p,
 158                                         nsCycleCollectionTraversalCallback &cb);
 159 };
 160
 161 class NS_COM_GLUE nsXPCOMCycleCollectionParticipant
 162     : public nsScriptObjectTracer
 163 {
 164 public:
 165     NS_IMETHOD Traverse(void *p, nsCycleCollectionTraversalCallback &cb);
 166
 167     NS_IMETHOD RootAndUnlinkJSObjects(void *p);
 168     NS_IMETHOD Unlink(void *p);
 169     NS_IMETHOD Unroot(void *p);
 170
 171     NS_IMETHOD_(void) Trace(void *p, TraceCallback cb, void *closure);
 172
 173     NS_IMETHOD_(void) UnmarkPurple(nsISupports *p);
 174
 175     PRBool CheckForRightISupports(nsISupports *s);
 176 };
 177
 178 #undef IMETHOD_VISIBILITY
 179 #define IMETHOD_VISIBILITY NS_VISIBILITY_HIDDEN
 180
 181 ///////////////////////////////////////////////////////////////////////////////
 182 // Helpers for implementing a QI to nsXPCOMCycleCollectionParticipant
 183 ///////////////////////////////////////////////////////////////////////////////
 184
 185 #define NS_CYCLE_COLLECTION_INNERCLASS                                         \
 186         cycleCollection
 187
 188 #define NS_CYCLE_COLLECTION_CLASSNAME(_class)                                  \
 189         _class::NS_CYCLE_COLLECTION_INNERCLASS
 190
 191 #define NS_CYCLE_COLLECTION_INNERNAME                                          \
 192         _cycleCollectorGlobal
 193
 194 #define NS_CYCLE_COLLECTION_NAME(_class)                                       \
 195         _class::NS_CYCLE_COLLECTION_INNERNAME
 196
 197 #define NS_IMPL_QUERY_CYCLE_COLLECTION(_class)                                 \
 198   if ( aIID.Equals(NS_GET_IID(nsXPCOMCycleCollectionParticipant)) ) {          \
 199     *aInstancePtr = & NS_CYCLE_COLLECTION_NAME(_class);                        \
 200     return NS_OK;                                                              \
 201   } else
 202
 203 #define NS_IMPL_QUERY_CYCLE_COLLECTION_ISUPPORTS(_class)                       \
 204   if ( aIID.Equals(NS_GET_IID(nsCycleCollectionISupports)) )                   \
 205     foundInterface = NS_CYCLE_COLLECTION_CLASSNAME(_class)::Upcast(this);      \
 206   else
 207
 208 #define NS_INTERFACE_MAP_ENTRY_CYCLE_COLLECTION(_class)                        \
 209   NS_IMPL_QUERY_CYCLE_COLLECTION(_class)
 210
 211 #define NS_INTERFACE_MAP_ENTRY_CYCLE_COLLECTION_ISUPPORTS(_class)              \
 212   NS_IMPL_QUERY_CYCLE_COLLECTION_ISUPPORTS(_class)
 213
 214 #define NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(_class)                      \
 215   NS_INTERFACE_MAP_ENTRY_CYCLE_COLLECTION(_class)                              \
 216   NS_INTERFACE_MAP_ENTRY_CYCLE_COLLECTION_ISUPPORTS(_class)
 217
 218 #define NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(_class)                        \
 219   NS_INTERFACE_MAP_BEGIN(_class)                                               \
 220     NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(_class)
 221
 222 #define NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(_class)              \
 223   NS_INTERFACE_MAP_BEGIN(_class)                                               \
 224     NS_INTERFACE_MAP_ENTRY_CYCLE_COLLECTION(_class)
 225
 226 #define NS_INTERFACE_TABLE_TO_MAP_SEGUE_CYCLE_COLLECTION(_class)  \
 227   if (rv == NS_OK) return rv; \
 228   nsISupports* foundInterface; \
 229   NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(_class)
 230
 231 #define NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(_class)            \
 232   NS_IMETHODIMP _class::QueryInterface(REFNSIID aIID, void** aInstancePtr)    \
 233   {                                                                           \
 234     NS_PRECONDITION(aInstancePtr, "null out param");                          \
 235                                                                               \
 236     if ( aIID.Equals(NS_GET_IID(nsXPCOMCycleCollectionParticipant)) ) {       \
 237       *aInstancePtr = &NS_CYCLE_COLLECTION_NAME(_class);                      \
 238       return NS_OK;                                                           \
 239     }                                                                         \
 240     nsresult rv;
 241
 242 #define NS_CYCLE_COLLECTION_UPCAST(obj, clazz)                                 \
 243   NS_CYCLE_COLLECTION_CLASSNAME(clazz)::Upcast(obj)
 244
 245 ///////////////////////////////////////////////////////////////////////////////
 246 // Helpers for implementing nsCycleCollectionParticipant::RootAndUnlinkJSObjects
 247 ///////////////////////////////////////////////////////////////////////////////
 248
 249 #define NS_IMPL_CYCLE_COLLECTION_ROOT_BEGIN(_class)                            \
 250   NS_IMETHODIMP                                                                \
 251   NS_CYCLE_COLLECTION_CLASSNAME(_class)::RootAndUnlinkJSObjects(void *p)       \
 252   {                                                                            \
 253     nsISupports *s = static_cast<nsISupports*>(p);                             \
 254     NS_ASSERTION(CheckForRightISupports(s),                                    \
 255                  "not the nsISupports pointer we expect");                     \
 256     nsXPCOMCycleCollectionParticipant::RootAndUnlinkJSObjects(s);              \
 257     _class *tmp = Downcast(s);
 258
 259 #define NS_IMPL_CYCLE_COLLECTION_ROOT_BEGIN_NATIVE(_class, _root_function)     \
 260   NS_IMETHODIMP                                                                \
 261   NS_CYCLE_COLLECTION_CLASSNAME(_class)::RootAndUnlinkJSObjects(void *p)       \
 262   {                                                                            \
 263     _class *tmp = static_cast<_class*>(p);                                     \
 264     tmp->_root_function();
 265
 266 #define NS_IMPL_CYCLE_COLLECTION_ROOT_END                                      \
 267     return NS_OK;                                                              \
 268   }
 269
 270 ///////////////////////////////////////////////////////////////////////////////
 271 // Helpers for implementing nsCycleCollectionParticipant::Unlink
 272 ///////////////////////////////////////////////////////////////////////////////
 273
 274 #define NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class)                          \
 275   NS_IMETHODIMP                                                                \
 276   NS_CYCLE_COLLECTION_CLASSNAME(_class)::Unlink(void *p)                       \
 277   {                                                                            \
 278     nsISupports *s = static_cast<nsISupports*>(p);                             \
 279     NS_ASSERTION(CheckForRightISupports(s),                                    \
 280                  "not the nsISupports pointer we expect");                     \
 281     _class *tmp = Downcast(s);
 282
 283 #define NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(_class, _base_class)   \
 284   NS_IMETHODIMP                                                                \
 285   NS_CYCLE_COLLECTION_CLASSNAME(_class)::Unlink(void *p)                       \
 286   {                                                                            \
 287     nsISupports *s = static_cast<nsISupports*>(p);                             \
 288     NS_ASSERTION(CheckForRightISupports(s),                                    \
 289                  "not the nsISupports pointer we expect");                     \
 290     _class *tmp = static_cast<_class*>(Downcast(s));                           \
 291     NS_CYCLE_COLLECTION_CLASSNAME(_base_class)::Unlink(s);
 292
 293 #define NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_NATIVE(_class)                   \
 294   NS_IMETHODIMP                                                                \
 295   NS_CYCLE_COLLECTION_CLASSNAME(_class)::Unlink(void *p)                       \
 296   {                                                                            \
 297     _class *tmp = static_cast<_class*>(p);
 298
 299 #define NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_field)                       \
 300     tmp->_field = NULL;
 301
 302 #define NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMARRAY(_field)                     \
 303     tmp->_field.Clear();
 304
 305 #define NS_IMPL_CYCLE_COLLECTION_UNLINK_NSTARRAY(_field)                       \
 306     tmp->_field.Clear();
 307
 308 #define NS_IMPL_CYCLE_COLLECTION_UNLINK_END                                    \
 309     return NS_OK;                                                              \
 310   }
 311
 312 #define NS_IMPL_CYCLE_COLLECTION_UNLINK_0(_class)                              \
 313   NS_IMETHODIMP                                                                \
 314   NS_CYCLE_COLLECTION_CLASSNAME(_class)::Unlink(void *p)                       \
 315   {                                                                            \
 316     NS_ASSERTION(CheckForRightISupports(static_cast<nsISupports*>(p)),         \
 317                  "not the nsISupports pointer we expect");                     \
 318     return NS_OK;                                                              \
 319   }
 320
 321 #define NS_IMPL_CYCLE_COLLECTION_UNLINK_NATIVE_0(_class)                       \
 322   NS_IMETHODIMP                                                                \
 323   NS_CYCLE_COLLECTION_CLASSNAME(_class)::Unlink(void *p)                       \
 324   {                                                                            \
 325     return NS_OK;                                                              \
 326   }
 327
 328
 329 ///////////////////////////////////////////////////////////////////////////////
 330 // Helpers for implementing nsCycleCollectionParticipant::Traverse
 331 ///////////////////////////////////////////////////////////////////////////////
 332
 333 #define NS_IMPL_CYCLE_COLLECTION_DESCRIBE(_class, _refcnt)                     \
 334     cb.DescribeNode(RefCounted, _refcnt, sizeof(_class), #_class);
 335
 336 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(_class)               \
 337   NS_IMETHODIMP                                                                \
 338   NS_CYCLE_COLLECTION_CLASSNAME(_class)::Traverse                              \
 339                          (void *p,                                             \
 340                           nsCycleCollectionTraversalCallback &cb)              \
 341   {                                                                            \
 342     nsISupports *s = static_cast<nsISupports*>(p);                             \
 343     NS_ASSERTION(CheckForRightISupports(s),                                    \
 344                  "not the nsISupports pointer we expect");                     \
 345     _class *tmp = static_cast<_class*>(Downcast(s));
 346
 347 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class)                        \
 348   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(_class)                     \
 349   NS_IMPL_CYCLE_COLLECTION_DESCRIBE(_class, tmp->mRefCnt.get())
 350
 351 // Base class' CC participant should return NS_SUCCESS_INTERRUPTED_TRAVERSE
 352 // from Traverse if it wants derived classes to not traverse anything from
 353 // their CC participant.
 354 #define NS_SUCCESS_INTERRUPTED_TRAVERSE \
 355   NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_XPCOM, 2)
 356
 357 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(_class, _base_class) \
 358   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(_class)                     \
 359     if (NS_CYCLE_COLLECTION_CLASSNAME(_base_class)::Traverse(s, cb) ==         \
 360         NS_SUCCESS_INTERRUPTED_TRAVERSE) {                                     \
 361       return NS_SUCCESS_INTERRUPTED_TRAVERSE;                                  \
 362     }
 363
 364 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE_BEGIN(_class)                 \
 365   NS_IMETHODIMP                                                                \
 366   NS_CYCLE_COLLECTION_CLASSNAME(_class)::Traverse                              \
 367                          (void *p,                                             \
 368                           nsCycleCollectionTraversalCallback &cb)              \
 369   {                                                                            \
 370     _class *tmp = static_cast<_class*>(p);                                     \
 371     NS_IMPL_CYCLE_COLLECTION_DESCRIBE(_class, tmp->mRefCnt.get())
 372
 373 #define NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(_cb, _name)                         \
 374   PR_BEGIN_MACRO                                                               \
 375     if (NS_UNLIKELY((_cb).WantDebugInfo())) {                                  \
 376       (_cb).NoteNextEdgeName(_name);                                           \
 377     }                                                                          \
 378   PR_END_MACRO
 379
 380 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(_field)                       \
 381   PR_BEGIN_MACRO                                                               \
 382     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, #_field);                           \
 383     cb.NoteXPCOMChild(tmp->_field);                                            \
 384   PR_END_MACRO;
 385
 386 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_field)                     \
 387   PR_BEGIN_MACRO                                                               \
 388     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, #_field);                           \
 389     cb.NoteXPCOMChild(tmp->_field.get());                                      \
 390   PR_END_MACRO;
 391
 392 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR_AMBIGUOUS(_field, _base)    \
 393   PR_BEGIN_MACRO                                                               \
 394     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, #_field);                           \
 395     cb.NoteXPCOMChild(NS_ISUPPORTS_CAST(_base*, tmp->_field));                 \
 396   PR_END_MACRO;
 397
 398 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMARRAY(_field)                   \
 399     {                                                                          \
 400       PRInt32 i;                                                               \
 401       for (i = 0; i < tmp->_field.Count(); ++i) {                              \
 402         NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, #_field "[i]");                 \
 403         cb.NoteXPCOMChild(tmp->_field[i]);                                     \
 404       }                                                                        \
 405     }
 406
 407 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE_PTR(_ptr, _ptr_class, _name)  \
 408   PR_BEGIN_MACRO                                                               \
 409     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, _name);                             \
 410     cb.NoteNativeChild(_ptr, &NS_CYCLE_COLLECTION_NAME(_ptr_class));           \
 411   PR_END_MACRO;
 412
 413 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE_MEMBER(_field, _field_class)  \
 414   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE_PTR(tmp->_field, _field_class,      \
 415                                                #_field)
 416
 417 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSTARRAY(_array, _element_class,     \
 418                                                    _name)                      \
 419     {                                                                          \
 420       PRUint32 i, length = (_array).Length();                                  \
 421       for (i = 0; i < length; ++i)                                             \
 422         NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE_PTR((_array)[i],              \
 423                                                      _element_class,           \
 424                                                      _name "[i]");             \
 425     }
 426
 427 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSTARRAY_MEMBER(_field,              \
 428                                                           _element_class)      \
 429     NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSTARRAY(tmp->_field, _element_class,    \
 430                                                #_field)
 431
 432 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS                       \
 433     TraverseScriptObjects(tmp, cb);
 434
 435 #define NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END                                  \
 436     return NS_OK;                                                              \
 437   }
 438
 439 ///////////////////////////////////////////////////////////////////////////////
 440 // Helpers for implementing nsScriptObjectTracer::Trace
 441 ///////////////////////////////////////////////////////////////////////////////
 442
 443 #define NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(_class)                           \
 444   void                                                                         \
 445   NS_CYCLE_COLLECTION_CLASSNAME(_class)::Trace(void *p,                        \
 446                                                TraceCallback aCallback,        \
 447                                                void *aClosure)                 \
 448   {                                                                            \
 449     nsISupports *s = static_cast<nsISupports*>(p);                             \
 450     NS_ASSERTION(CheckForRightISupports(s),                                    \
 451                  "not the nsISupports pointer we expect");                     \
 452     _class *tmp = Downcast(s);
 453
 454 #define NS_IMPL_CYCLE_COLLECTION_TRACE_NATIVE_BEGIN(_class)                    \
 455   void                                                                         \
 456   NS_CYCLE_COLLECTION_CLASSNAME(_class)::Trace(void *p,                        \
 457                                                TraceCallback aCallback,        \
 458                                                void *aClosure)                 \
 459   {                                                                            \
 460     _class *tmp = static_cast<_class*>(p);
 461
 462 #define NS_IMPL_CYCLE_COLLECTION_TRACE_CALLBACK(_langID, _object)              \
 463   if (_object)                                                                 \
 464     aCallback(_langID, _object, aClosure);
 465
 466 #define NS_IMPL_CYCLE_COLLECTION_TRACE_MEMBER_CALLBACK(_langID, _field)        \
 467   NS_IMPL_CYCLE_COLLECTION_TRACE_CALLBACK(_langID, tmp->_field)
 468
 469 #define NS_IMPL_CYCLE_COLLECTION_TRACE_JS_CALLBACK(_object)                    \
 470   NS_IMPL_CYCLE_COLLECTION_TRACE_CALLBACK(nsIProgrammingLanguage::JAVASCRIPT,  \
 471                                           _object)
 472
 473 #define NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(_field)              \
 474   NS_IMPL_CYCLE_COLLECTION_TRACE_JS_CALLBACK(tmp->_field)
 475
 476 // NB: The (void)tmp; hack in the TRACE_END macro exists to support
 477 // implementations that don't need to do anything in their Trace method.
 478 // Without this hack, some compilers warn about the unused tmp local.
 479 #define NS_IMPL_CYCLE_COLLECTION_TRACE_END                                     \
 480       (void)tmp;                                                               \
 481   }
 482
 483 ///////////////////////////////////////////////////////////////////////////////
 484 // Helpers for implementing a concrete nsCycleCollectionParticipant
 485 ///////////////////////////////////////////////////////////////////////////////
 486
 487 #define NS_CYCLE_COLLECTION_PARTICIPANT_INSTANCE                               \
 488   static NS_CYCLE_COLLECTION_INNERCLASS NS_CYCLE_COLLECTION_INNERNAME;
 489
 490 #define NS_DECL_CYCLE_COLLECTION_CLASS_BODY_NO_UNLINK(_class, _base)           \
 491 public:                                                                        \
 492   NS_IMETHOD Traverse(void *p,                                                 \
 493                       nsCycleCollectionTraversalCallback &cb);                 \
 494   NS_IMETHOD_(void) UnmarkPurple(nsISupports *s)                               \
 495   {                                                                            \
 496     Downcast(s)->UnmarkPurple();                                               \
 497   }                                                                            \
 498   static _class* Downcast(nsISupports* s)                                      \
 499   {                                                                            \
 500     return static_cast<_class*>(static_cast<_base*>(s));                       \
 501   }                                                                            \
 502   static nsISupports* Upcast(_class *p)                                        \
 503   {                                                                            \
 504     return NS_ISUPPORTS_CAST(_base*, p);                                       \
 505   }
 506
 507 #define NS_DECL_CYCLE_COLLECTION_CLASS_BODY(_class, _base)                     \
 508   NS_DECL_CYCLE_COLLECTION_CLASS_BODY_NO_UNLINK(_class, _base)                 \
 509   NS_IMETHOD Unlink(void *p);
 510
 511 #define NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(_class, _base)                \
 512 class NS_CYCLE_COLLECTION_INNERCLASS                                           \
 513  : public nsXPCOMCycleCollectionParticipant                                    \
 514 {                                                                              \
 515   NS_DECL_CYCLE_COLLECTION_CLASS_BODY(_class, _base)                           \
 516 };                                                                             \
 517 NS_CYCLE_COLLECTION_PARTICIPANT_INSTANCE
 518
 519 #define NS_DECL_CYCLE_COLLECTION_CLASS(_class)                                 \
 520   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(_class, _class)
 521
 522 // Cycle collector helper for classes that don't want to unlink anything.
 523 // Note: if this is used a lot it might make sense to have a base class that
 524 //       doesn't do anything in RootAndUnlinkJSObjects/Unlink/Unroot.
 525 #define NS_DECL_CYCLE_COLLECTION_CLASS_NO_UNLINK(_class)                       \
 526 class NS_CYCLE_COLLECTION_INNERCLASS                                           \
 527  : public nsXPCOMCycleCollectionParticipant                                    \
 528 {                                                                              \
 529   NS_DECL_CYCLE_COLLECTION_CLASS_BODY_NO_UNLINK(_class, _class)                \
 530   NS_IMETHOD RootAndUnlinkJSObjects(void *p)                                   \
 531   {                                                                            \
 532     return NS_OK;                                                              \
 533   }                                                                            \
 534   NS_IMETHOD Unlink(void *p)                                                   \
 535   {                                                                            \
 536     return NS_OK;                                                              \
 537   }                                                                            \
 538   NS_IMETHOD Unroot(void *p)                                                   \
 539   {                                                                            \
 540     return NS_OK;                                                              \
 541   }                                                                            \
 542 };                                                                             \
 543 NS_CYCLE_COLLECTION_PARTICIPANT_INSTANCE
 544
 545 #define NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(_class, _base)  \
 546 class NS_CYCLE_COLLECTION_INNERCLASS                                           \
 547  : public nsXPCOMCycleCollectionParticipant                                    \
 548 {                                                                              \
 549   NS_IMETHOD RootAndUnlinkJSObjects(void *p);                                  \
 550   NS_DECL_CYCLE_COLLECTION_CLASS_BODY(_class, _base)                           \
 551   NS_IMETHOD_(void) Trace(void *p, TraceCallback cb, void *closure);           \
 552 };                                                                             \
 553 NS_CYCLE_COLLECTION_PARTICIPANT_INSTANCE
 554
 555 #define NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(_class)  \
 556   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(_class, _class)
 557
 558 #define NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_BODY_NO_UNLINK(_class,        \
 559                                                                 _base_class)   \
 560 public:                                                                        \
 561   NS_IMETHOD Traverse(void *p,                                                 \
 562                       nsCycleCollectionTraversalCallback &cb);                 \
 563   static _class* Downcast(nsISupports* s)                                      \
 564   {                                                                            \
 565     return static_cast<_class*>(static_cast<_base_class*>(                     \
 566       NS_CYCLE_COLLECTION_CLASSNAME(_base_class)::Downcast(s)));               \
 567   }
 568
 569 #define NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_BODY(_class, _base_class)     \
 570   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_BODY_NO_UNLINK(_class, _base_class) \
 571   NS_IMETHOD Unlink(void *p);
 572
 573 #define NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(_class, _base_class)          \
 574 class NS_CYCLE_COLLECTION_INNERCLASS                                           \
 575  : public NS_CYCLE_COLLECTION_CLASSNAME(_base_class)                           \
 576 {                                                                              \
 577 public:                                                                        \
 578   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_BODY(_class, _base_class)           \
 579 };                                                                             \
 580 NS_CYCLE_COLLECTION_PARTICIPANT_INSTANCE
 581
 582 #define NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_NO_UNLINK(_class,             \
 583                                                            _base_class)        \
 584 class NS_CYCLE_COLLECTION_INNERCLASS                                           \
 585  : public NS_CYCLE_COLLECTION_CLASSNAME(_base_class)                           \
 586 {                                                                              \
 587 public:                                                                        \
 588   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_BODY_NO_UNLINK(_class, _base_class) \
 589 };                                                                             \
 590 NS_CYCLE_COLLECTION_PARTICIPANT_INSTANCE
 591
 592 #define NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(_class,         \
 593                                                                _base_class)    \
 594 class NS_CYCLE_COLLECTION_INNERCLASS                                           \
 595  : public NS_CYCLE_COLLECTION_CLASSNAME(_base_class)                           \
 596 {                                                                              \
 597 public:                                                                        \
 598   NS_IMETHOD RootAndUnlinkJSObjects(void *p);                                  \
 599   NS_IMETHOD_(void) Trace(void *p, TraceCallback cb, void *closure);           \
 600   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_BODY(_class, _base_class)           \
 601 };                                                                             \
 602 NS_CYCLE_COLLECTION_PARTICIPANT_INSTANCE
 603
 604 /**
 605  * This implements a stub UnmarkPurple function for classes that want to be
 606  * traversed but whose AddRef/Release functions don't add/remove them to/from
 607  * the purple buffer. If you're just using NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 608  * then you don't need this.
 609  */
 610 #define NS_DECL_CYCLE_COLLECTION_UNMARK_PURPLE_STUB(_class)                    \
 611   NS_IMETHODIMP_(void) UnmarkPurple()                                          \
 612   {                                                                            \
 613   }                                                                            \
 614
 615 #define NS_IMPL_CYCLE_COLLECTION_CLASS(_class)                                 \
 616   NS_CYCLE_COLLECTION_CLASSNAME(_class) NS_CYCLE_COLLECTION_NAME(_class);
 617
 618 #define NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS_BODY                             \
 619   public:                                                                      \
 620     NS_IMETHOD RootAndUnlinkJSObjects(void *n);                                \
 621     NS_IMETHOD Unlink(void *n);                                                \
 622     NS_IMETHOD Unroot(void *n);                                                \
 623     NS_IMETHOD Traverse(void *n,                                               \
 624                       nsCycleCollectionTraversalCallback &cb);
 625
 626 #define NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(_class)                          \
 627   class NS_CYCLE_COLLECTION_INNERCLASS                                         \
 628    : public nsCycleCollectionParticipant                                       \
 629   {                                                                            \
 630      NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS_BODY                                \
 631   };                                                                           \
 632   NS_CYCLE_COLLECTION_PARTICIPANT_INSTANCE
 633
 634 #define NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(_class)            \
 635   class NS_CYCLE_COLLECTION_INNERCLASS                                         \
 636    : public nsScriptObjectTracer                                               \
 637   {                                                                            \
 638     NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS_BODY                                 \
 639     NS_IMETHOD_(void) Trace(void *p, TraceCallback cb, void *closure);         \
 640   };                                                                           \
 641   NS_CYCLE_COLLECTION_PARTICIPANT_INSTANCE
 642
 643 #define NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(_class, _root_function)           \
 644   NS_IMETHODIMP                                                                \
 645   NS_CYCLE_COLLECTION_CLASSNAME(_class)::RootAndUnlinkJSObjects(void *p)       \
 646   {                                                                            \
 647     _class *tmp = static_cast<_class*>(p);                                     \
 648     tmp->_root_function();                                                     \
 649     return NS_OK;                                                              \
 650   }
 651
 652 #define NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(_class, _unroot_function)       \
 653   NS_IMETHODIMP                                                                \
 654   NS_CYCLE_COLLECTION_CLASSNAME(_class)::Unroot(void *p)                       \
 655   {                                                                            \
 656     _class *tmp = static_cast<_class*>(p);                                     \
 657     tmp->_unroot_function();                                                   \
 658     return NS_OK;                                                              \
 659   }
 660
 661 #define NS_IMPL_CYCLE_COLLECTION_0(_class)                                     \
 662  NS_IMPL_CYCLE_COLLECTION_CLASS(_class)                                        \
 663  NS_IMPL_CYCLE_COLLECTION_UNLINK_0(_class)                                     \
 664  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class)                               \
 665  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 666
 667 #define NS_IMPL_CYCLE_COLLECTION_1(_class, _f)                                 \
 668  NS_IMPL_CYCLE_COLLECTION_CLASS(_class)                                        \
 669  NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class)                                 \
 670  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f)                                  \
 671  NS_IMPL_CYCLE_COLLECTION_UNLINK_END                                           \
 672  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class)                               \
 673  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f)                                \
 674  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 675
 676 #define NS_IMPL_CYCLE_COLLECTION_2(_class, _f1, _f2)                           \
 677  NS_IMPL_CYCLE_COLLECTION_CLASS(_class)                                        \
 678  NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class)                                 \
 679  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f1)                                 \
 680  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f2)                                 \
 681  NS_IMPL_CYCLE_COLLECTION_UNLINK_END                                           \
 682  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class)                               \
 683  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f1)                               \
 684  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f2)                               \
 685  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 686
 687 #define NS_IMPL_CYCLE_COLLECTION_3(_class, _f1, _f2, _f3)                      \
 688  NS_IMPL_CYCLE_COLLECTION_CLASS(_class)                                        \
 689  NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class)                                 \
 690  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f1)                                 \
 691  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f2)                                 \
 692  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f3)                                 \
 693  NS_IMPL_CYCLE_COLLECTION_UNLINK_END                                           \
 694  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class)                               \
 695  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f1)                               \
 696  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f2)                               \
 697  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f3)                               \
 698  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 699
 700 #define NS_IMPL_CYCLE_COLLECTION_4(_class, _f1, _f2, _f3, _f4)                 \
 701  NS_IMPL_CYCLE_COLLECTION_CLASS(_class)                                        \
 702  NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class)                                 \
 703  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f1)                                 \
 704  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f2)                                 \
 705  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f3)                                 \
 706  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f4)                                 \
 707  NS_IMPL_CYCLE_COLLECTION_UNLINK_END                                           \
 708  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class)                               \
 709  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f1)                               \
 710  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f2)                               \
 711  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f3)                               \
 712  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f4)                               \
 713  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 714
 715 #define NS_IMPL_CYCLE_COLLECTION_5(_class, _f1, _f2, _f3, _f4, _f5)            \
 716  NS_IMPL_CYCLE_COLLECTION_CLASS(_class)                                        \
 717  NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class)                                 \
 718  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f1)                                 \
 719  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f2)                                 \
 720  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f3)                                 \
 721  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f4)                                 \
 722  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f5)                                 \
 723  NS_IMPL_CYCLE_COLLECTION_UNLINK_END                                           \
 724  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class)                               \
 725  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f1)                               \
 726  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f2)                               \
 727  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f3)                               \
 728  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f4)                               \
 729  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f5)                               \
 730  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 731
 732 #define NS_IMPL_CYCLE_COLLECTION_6(_class, _f1, _f2, _f3, _f4, _f5, _f6)       \
 733  NS_IMPL_CYCLE_COLLECTION_CLASS(_class)                                        \
 734  NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class)                                 \
 735  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f1)                                 \
 736  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f2)                                 \
 737  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f3)                                 \
 738  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f4)                                 \
 739  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f5)                                 \
 740  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f6)                                 \
 741  NS_IMPL_CYCLE_COLLECTION_UNLINK_END                                           \
 742  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class)                               \
 743  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f1)                               \
 744  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f2)                               \
 745  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f3)                               \
 746  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f4)                               \
 747  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f5)                               \
 748  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f6)                               \
 749  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 750
 751 #define NS_IMPL_CYCLE_COLLECTION_7(_class, _f1, _f2, _f3, _f4, _f5, _f6, _f7)  \
 752  NS_IMPL_CYCLE_COLLECTION_CLASS(_class)                                        \
 753  NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class)                                 \
 754  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f1)                                 \
 755  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f2)                                 \
 756  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f3)                                 \
 757  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f4)                                 \
 758  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f5)                                 \
 759  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f6)                                 \
 760  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f7)                                 \
 761  NS_IMPL_CYCLE_COLLECTION_UNLINK_END                                           \
 762  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class)                               \
 763  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f1)                               \
 764  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f2)                               \
 765  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f3)                               \
 766  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f4)                               \
 767  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f5)                               \
 768  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f6)                               \
 769  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f7)                               \
 770  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 771
 772 #define NS_IMPL_CYCLE_COLLECTION_8(_class, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8) \
 773  NS_IMPL_CYCLE_COLLECTION_CLASS(_class)                                        \
 774  NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class)                                 \
 775  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f1)                                 \
 776  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f2)                                 \
 777  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f3)                                 \
 778  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f4)                                 \
 779  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f5)                                 \
 780  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f6)                                 \
 781  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f7)                                 \
 782  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_f8)                                 \
 783  NS_IMPL_CYCLE_COLLECTION_UNLINK_END                                           \
 784  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class)                               \
 785  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f1)                               \
 786  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f2)                               \
 787  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f3)                               \
 788  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f4)                               \
 789  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f5)                               \
 790  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f6)                               \
 791  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f7)                               \
 792  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_f8)                               \
 793  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 794
 795 #endif // nsCycleCollectionParticipant_h__