Global Metrics

Spaces Data

Minimal test - lines (96, 120)

Code

struct TraceCallbackFunc : public TraceCallbacks {
  typedef void (*Func)(JS::GCCellPtr aPtr, const char* aName, void* aClosure);

  explicit TraceCallbackFunc(Func aCb) : mCallback(aCb) {}

  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(nsWrapperCache* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(JS::TenuredHeap* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const override;

 private:
  Func mCallback;
};

Minimal test - lines (58, 58)

Code

class nsWrapperCache;

Minimal test - lines (56, 56)

Code

class nsCycleCollectionTraversalCallback;

Minimal test - lines (60, 65)

Code

namespace JS {
template 
class Heap;
template 
class TenuredHeap;
} /* namespace JS */

Minimal test - lines (57, 57)

Code

class nsISupports;

Minimal test - lines (48, 254)

Code

class nsCycleCollectionISupports {
 public:
  NS_DECLARE_STATIC_IID_ACCESSOR(NS_CYCLECOLLECTIONISUPPORTS_IID)
};

NS_DEFINE_STATIC_IID_ACCESSOR(nsCycleCollectionISupports,
                              NS_CYCLECOLLECTIONISUPPORTS_IID)

class nsCycleCollectionTraversalCallback;
class nsISupports;
class nsWrapperCache;

namespace JS {
template 
class Heap;
template 
class TenuredHeap;
} /* namespace JS */

/*
 * A struct defining pure virtual methods which are called when tracing cycle
 * collection paticipants.  The appropriate method is called depending on the
 * type of JS GC thing.
 */
struct TraceCallbacks {
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(nsWrapperCache* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(JS::TenuredHeap* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const = 0;
};

/*
 * An implementation of TraceCallbacks that calls a single function for all JS
 * GC thing types encountered. Implemented in
 * nsCycleCollectorTraceJSHelpers.cpp.
 */
struct TraceCallbackFunc : public TraceCallbacks {
  typedef void (*Func)(JS::GCCellPtr aPtr, const char* aName, void* aClosure);

  explicit TraceCallbackFunc(Func aCb) : mCallback(aCb) {}

  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(nsWrapperCache* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(JS::TenuredHeap* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const override;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const override;

 private:
  Func mCallback;
};

/**
 * Participant implementation classes
 */
class NS_NO_VTABLE nsCycleCollectionParticipant {
 public:
  using Flags = uint8_t;
  static constexpr Flags FlagMightSkip = 1u << 0;
  static constexpr Flags FlagTraverseShouldTrace = 1u << 1;
  static constexpr Flags FlagMultiZoneJSHolder = 1u << 2;
  static constexpr Flags AllFlags =
      FlagMightSkip | FlagTraverseShouldTrace | FlagMultiZoneJSHolder;

  constexpr explicit nsCycleCollectionParticipant(Flags aFlags)
      : mFlags(aFlags) {
    MOZ_ASSERT((aFlags & ~AllFlags) == 0);
  }

  NS_IMETHOD TraverseNative(void* aPtr,
                            nsCycleCollectionTraversalCallback& aCb) = 0;

  nsresult TraverseNativeAndJS(void* aPtr,
                               nsCycleCollectionTraversalCallback& aCb) {
    nsresult rv = TraverseNative(aPtr, aCb);
    if (TraverseShouldTrace()) {
      // Note, we always call Trace, even if Traverse returned
      // NS_SUCCESS_INTERRUPTED_TRAVERSE.
      TraceCallbackFunc noteJsChild(&nsCycleCollectionParticipant::NoteJSChild);
      Trace(aPtr, noteJsChild, &aCb);
    }
    return rv;
  }

  // Implemented in nsCycleCollectorTraceJSHelpers.cpp.
  static void NoteJSChild(JS::GCCellPtr aGCThing, const char* aName,
                          void* aClosure);

  NS_IMETHOD_(void) Root(void* aPtr) = 0;
  NS_IMETHOD_(void) Unlink(void* aPtr) = 0;
  NS_IMETHOD_(void) Unroot(void* aPtr) = 0;
  NS_IMETHOD_(const char*) ClassName() = 0;

  NS_IMETHOD_(void)
  Trace(void* aPtr, const TraceCallbacks& aCb, void* aClosure) {}

  // CanSkip is called during nsCycleCollector_forgetSkippable.  If it returns
  // true, aPtr is removed from the purple buffer and therefore might be left
  // out from the cycle collector graph the next time that's constructed (unless
  // it's reachable in some other way).
  //
  // CanSkip is allowed to expand the set of certainly-alive objects by removing
  // other objects from the purple buffer, marking JS things black (in the GC
  // sense), and so forth.  Furthermore, if aRemovingAllowed is true, this call
  // is allowed to remove aPtr itself from the purple buffer.
  //
  // Things can return true from CanSkip if either they know they have no
  // outgoing edges at all in the cycle collection graph (because then they
  // can't be parts of a cycle) or they know for sure they're alive.
  bool CanSkip(void* aPtr, bool aRemovingAllowed) {
    return MightSkip() ? CanSkipReal(aPtr, aRemovingAllowed) : false;
  }

  // CanSkipInCC is called during construction of the initial set of roots for
  // the cycle collector graph.  If it returns true, aPtr is left out of that
  // set of roots.  Note that the set of roots includes whatever is in the
  // purple buffer (after earlier CanSkip calls) plus various other sources of
  // roots, so an object can end up having CanSkipInCC called on it even if it
  // returned true from CanSkip.  One example of this would be an object that
  // can potentially trace JS things.
  //
  // CanSkipInCC is allowed to remove other objects from the purple buffer but
  // should not remove aPtr and should not mark JS things black.  It should also
  // not modify any reference counts.
  //
  // Things can return true from CanSkipInCC if either they know they have no
  // outgoing edges at all in the cycle collection graph or they know for sure
  // they're alive _and_ none of their outgoing edges are to gray (in the GC
  // sense) gcthings.  See also nsWrapperCache::HasNothingToTrace and
  // nsWrapperCache::HasKnownLiveWrapperAndDoesNotNeedTracing. The restriction
  // on not having outgoing edges to gray gcthings is because if we _do_ have
  // them that means we have a "strong" edge to a JS thing and since we're alive
  // we need to trace through it and mark keep them alive.  Outgoing edges to
  // C++ things don't matter here, because the criteria for when a CC
  // participant is considered alive are slightly different for JS and C++
  // things: JS things are only considered alive when reachable via an edge from
  // a live thing, while C++ things are also considered alive when their
  // refcount exceeds the number of edges via which they are reachable.
  bool CanSkipInCC(void* aPtr) {
    return MightSkip() ? CanSkipInCCReal(aPtr) : false;
  }

  // CanSkipThis is called during construction of the cycle collector graph,
  // when we traverse an edge to aPtr and consider adding it to the graph.  If
  // it returns true, aPtr is not added to the graph.
  //
  // CanSkipThis is not allowed to change the liveness or reference count of any
  // objects.
  //
  // Things can return true from CanSkipThis if either they know they have no
  // outgoing edges at all in the cycle collection graph or they know for sure
  // they're alive.
  //
  // Note that CanSkipThis doesn't have to worry about outgoing edges to gray GC
  // things, because if this object could have those it already got added to the
  // graph during root set construction.  An object should never have
  // CanSkipThis called on it if it has outgoing strong references to JS things.
  bool CanSkipThis(void* aPtr) {
    return MightSkip() ? CanSkipThisReal(aPtr) : false;
  }

  NS_IMETHOD_(void) DeleteCycleCollectable(void* aPtr) = 0;

  bool IsMultiZoneJSHolder() const { return mFlags & FlagMultiZoneJSHolder; }

 protected:
  NS_IMETHOD_(bool) CanSkipReal(void* aPtr, bool aRemovingAllowed) {
    NS_ASSERTION(false, "Forgot to implement CanSkipReal?");
    return false;
  }
  NS_IMETHOD_(bool) CanSkipInCCReal(void* aPtr) {
    NS_ASSERTION(false, "Forgot to implement CanSkipInCCReal?");
    return false;
  }
  NS_IMETHOD_(bool) CanSkipThisReal(void* aPtr) {
    NS_ASSERTION(false, "Forgot to implement CanSkipThisReal?");
    return false;
  }

 private:
  bool MightSkip() const { return mFlags & FlagMightSkip; }
  bool TraverseShouldTrace() const { return mFlags & FlagTraverseShouldTrace; }

  const Flags mFlags;
};

Minimal test - lines (125, 239)

Code

class NS_NO_VTABLE nsCycleCollectionParticipant {
 public:
  using Flags = uint8_t;
  static constexpr Flags FlagMightSkip = 1u << 0;
  static constexpr Flags FlagTraverseShouldTrace = 1u << 1;
  static constexpr Flags FlagMultiZoneJSHolder = 1u << 2;
  static constexpr Flags AllFlags =
      FlagMightSkip | FlagTraverseShouldTrace | FlagMultiZoneJSHolder;

  constexpr explicit nsCycleCollectionParticipant(Flags aFlags)
      : mFlags(aFlags) {
    MOZ_ASSERT((aFlags & ~AllFlags) == 0);
  }

  NS_IMETHOD TraverseNative(void* aPtr,
                            nsCycleCollectionTraversalCallback& aCb) = 0;

  nsresult TraverseNativeAndJS(void* aPtr,
                               nsCycleCollectionTraversalCallback& aCb) {
    nsresult rv = TraverseNative(aPtr, aCb);
    if (TraverseShouldTrace()) {
      // Note, we always call Trace, even if Traverse returned
      // NS_SUCCESS_INTERRUPTED_TRAVERSE.
      TraceCallbackFunc noteJsChild(&nsCycleCollectionParticipant::NoteJSChild);
      Trace(aPtr, noteJsChild, &aCb);
    }
    return rv;
  }

  // Implemented in nsCycleCollectorTraceJSHelpers.cpp.
  static void NoteJSChild(JS::GCCellPtr aGCThing, const char* aName,
                          void* aClosure);

  NS_IMETHOD_(void) Root(void* aPtr) = 0;
  NS_IMETHOD_(void) Unlink(void* aPtr) = 0;
  NS_IMETHOD_(void) Unroot(void* aPtr) = 0;
  NS_IMETHOD_(const char*) ClassName() = 0;

  NS_IMETHOD_(void)
  Trace(void* aPtr, const TraceCallbacks& aCb, void* aClosure) {}

  // CanSkip is called during nsCycleCollector_forgetSkippable.  If it returns
  // true, aPtr is removed from the purple buffer and therefore might be left
  // out from the cycle collector graph the next time that's constructed (unless
  // it's reachable in some other way).
  //
  // CanSkip is allowed to expand the set of certainly-alive objects by removing
  // other objects from the purple buffer, marking JS things black (in the GC
  // sense), and so forth.  Furthermore, if aRemovingAllowed is true, this call
  // is allowed to remove aPtr itself from the purple buffer.
  //
  // Things can return true from CanSkip if either they know they have no
  // outgoing edges at all in the cycle collection graph (because then they
  // can't be parts of a cycle) or they know for sure they're alive.
  bool CanSkip(void* aPtr, bool aRemovingAllowed) {
    return MightSkip() ? CanSkipReal(aPtr, aRemovingAllowed) : false;
  }

  // CanSkipInCC is called during construction of the initial set of roots for
  // the cycle collector graph.  If it returns true, aPtr is left out of that
  // set of roots.  Note that the set of roots includes whatever is in the
  // purple buffer (after earlier CanSkip calls) plus various other sources of
  // roots, so an object can end up having CanSkipInCC called on it even if it
  // returned true from CanSkip.  One example of this would be an object that
  // can potentially trace JS things.
  //
  // CanSkipInCC is allowed to remove other objects from the purple buffer but
  // should not remove aPtr and should not mark JS things black.  It should also
  // not modify any reference counts.
  //
  // Things can return true from CanSkipInCC if either they know they have no
  // outgoing edges at all in the cycle collection graph or they know for sure
  // they're alive _and_ none of their outgoing edges are to gray (in the GC
  // sense) gcthings.  See also nsWrapperCache::HasNothingToTrace and
  // nsWrapperCache::HasKnownLiveWrapperAndDoesNotNeedTracing. The restriction
  // on not having outgoing edges to gray gcthings is because if we _do_ have
  // them that means we have a "strong" edge to a JS thing and since we're alive
  // we need to trace through it and mark keep them alive.  Outgoing edges to
  // C++ things don't matter here, because the criteria for when a CC
  // participant is considered alive are slightly different for JS and C++
  // things: JS things are only considered alive when reachable via an edge from
  // a live thing, while C++ things are also considered alive when their
  // refcount exceeds the number of edges via which they are reachable.
  bool CanSkipInCC(void* aPtr) {
    return MightSkip() ? CanSkipInCCReal(aPtr) : false;
  }

  // CanSkipThis is called during construction of the cycle collector graph,
  // when we traverse an edge to aPtr and consider adding it to the graph.  If
  // it returns true, aPtr is not added to the graph.
  //
  // CanSkipThis is not allowed to change the liveness or reference count of any
  // objects.
  //
  // Things can return true from CanSkipThis if either they know they have no
  // outgoing edges at all in the cycle collection graph or they know for sure
  // they're alive.
  //
  // Note that CanSkipThis doesn't have to worry about outgoing edges to gray GC
  // things, because if this object could have those it already got added to the
  // graph during root set construction.  An object should never have
  // CanSkipThis called on it if it has outgoing strong references to JS things.
  bool CanSkipThis(void* aPtr) {
    return MightSkip() ? CanSkipThisReal(aPtr) : false;
  }

  NS_IMETHOD_(void) DeleteCycleCollectable(void* aPtr) = 0;

  bool IsMultiZoneJSHolder() const { return mFlags & FlagMultiZoneJSHolder; }

 protected:
  NS_IMETHOD_(bool) CanSkipReal(void* aPtr, bool aRemovingAllowed) {
    NS_ASSERTION(false, "Forgot to implement CanSkipReal?");
    return false;
  }

Minimal test - lines (72, 89)

Code

struct TraceCallbacks {
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(nsWrapperCache* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(JS::TenuredHeap* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const = 0;
  virtual void Trace(JS::Heap* aPtr, const char* aName,
                     void* aClosure) const = 0;
};