Global Metrics

Spaces Data

Minimal test - lines (39, 44)

Code

class CategoryLeaf : public nsDepCharHashKey {
 public:
  explicit CategoryLeaf(const char* aKey)
      : nsDepCharHashKey(aKey), value(nullptr) {}
  const char* value;
};

Minimal test - lines (95, 143)

Code

class nsCategoryManager final : public nsICategoryManager,
                                public nsIMemoryReporter {
 public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSICATEGORYMANAGER
  NS_DECL_NSIMEMORYREPORTER

  /**
   * Suppress or unsuppress notifications of category changes to the
   * observer service. This is to be used by nsComponentManagerImpl
   * on startup while reading the stored category list.
   */
  nsresult SuppressNotifications(bool aSuppress);

  void AddCategoryEntry(const nsACString& aCategory, const nsACString& aKey,
                        const nsACString& aValue, bool aReplace,
                        nsACString& aOldValue);

  void AddCategoryEntry(const nsACString& aCategory, const nsACString& aKey,
                        const nsACString& aValue, bool aReplace = true) {
    nsCString oldValue;
    return AddCategoryEntry(aCategory, aKey, aValue, aReplace, oldValue);
  }

  static nsresult Create(nsISupports* aOuter, REFNSIID aIID, void** aResult);
  void InitMemoryReporter();

  static nsCategoryManager* GetSingleton();
  static void Destroy();

 private:
  static nsCategoryManager* gCategoryManager;

  nsCategoryManager();
  ~nsCategoryManager();

  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);

  CategoryNode* get_category(const nsACString& aName);
  void NotifyObservers(
      const char* aTopic,
      const nsACString& aCategoryName,  // must be a static string
      const nsACString& aEntryName);

  CategoryAllocator mArena;
  nsClassHashtable mTable;
  mozilla::Mutex mLock;
  bool mSuppressNotifications;
};

Minimal test - lines (19, 19)

Code

class nsIMemoryReporter;

Minimal test - lines (51, 88)

Code

class CategoryNode {
 public:
  nsresult GetLeaf(const nsACString& aEntryName, nsACString& aResult);

  nsresult AddLeaf(const nsACString& aEntryName, const nsACString& aValue,
                   bool aReplace, nsACString& aResult,
                   CategoryAllocator* aArena);

  void DeleteLeaf(const nsACString& aEntryName);

  void Clear() {
    mozilla::MutexAutoLock lock(mLock);
    mTable.Clear();
  }

  uint32_t Count() {
    mozilla::MutexAutoLock lock(mLock);
    uint32_t tCount = mTable.Count();
    return tCount;
  }

  nsresult Enumerate(nsISimpleEnumerator** aResult);

  // CategoryNode is arena-allocated, with the strings
  static CategoryNode* Create(CategoryAllocator* aArena);
  ~CategoryNode();
  void operator delete(void*) {}

  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf);

 private:
  CategoryNode() : mLock("CategoryLeaf") {}

  void* operator new(size_t aSize, CategoryAllocator* aArena);

  nsTHashtable mTable;
  mozilla::Mutex mLock;
};