xpcom/components/nsCategoryManager.h

   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/. */
   6
   7 #ifndef NSCATEGORYMANAGER_H
   8 #define NSCATEGORYMANAGER_H
   9
  10 #include "prio.h"
  11 #include "nsClassHashtable.h"
  12 #include "nsICategoryManager.h"
  13 #include "nsIMemoryReporter.h"
  14 #include "mozilla/ArenaAllocator.h"
  15 #include "mozilla/MemoryReporting.h"
  16 #include "mozilla/Mutex.h"
  17 #include "mozilla/Attributes.h"
  18
  19 class nsIMemoryReporter;
  20
  21 typedef mozilla::ArenaAllocator<1024 * 8, 8> CategoryAllocator;
  22
  23 /* 16d222a6-1dd2-11b2-b693-f38b02c021b2 */
  24 #define NS_CATEGORYMANAGER_CID                       \
  25   {                                                  \
  26     0x16d222a6, 0x1dd2, 0x11b2, {                    \
  27       0xb6, 0x93, 0xf3, 0x8b, 0x02, 0xc0, 0x21, 0xb2 \
  28     }                                                \
  29   }
  30
  31 /**
  32  * a "leaf-node", managed by the nsCategoryNode hashtable.
  33  *
  34  * we need to keep a "persistent value" (which will be written to the registry)
  35  * and a non-persistent value (for the current runtime): these are usually
  36  * the same, except when aPersist==false. The strings are permanently arena-
  37  * allocated, and will never go away.
  38  */
  39 class CategoryLeaf : public nsDepCharHashKey {
  40  public:
  41   explicit CategoryLeaf(const char* aKey)
  42       : nsDepCharHashKey(aKey), value(nullptr) {}
  43   const char* value;
  44 };
  45
  46 /**
  47  * CategoryNode keeps a hashtable of its entries.
  48  * the CategoryNode itself is permanently allocated in
  49  * the arena.
  50  */
  51 class CategoryNode {
  52  public:
  53   nsresult GetLeaf(const nsACString& aEntryName, nsACString& aResult);
  54
  55   nsresult AddLeaf(const nsACString& aEntryName, const nsACString& aValue,
  56                    bool aReplace, nsACString& aResult,
  57                    CategoryAllocator* aArena);
  58
  59   void DeleteLeaf(const nsACString& aEntryName);
  60
  61   void Clear() {
  62     mozilla::MutexAutoLock lock(mLock);
  63     mTable.Clear();
  64   }
  65
  66   uint32_t Count() {
  67     mozilla::MutexAutoLock lock(mLock);
  68     uint32_t tCount = mTable.Count();
  69     return tCount;
  70   }
  71
  72   nsresult Enumerate(nsISimpleEnumerator** aResult);
  73
  74   // CategoryNode is arena-allocated, with the strings
  75   static CategoryNode* Create(CategoryAllocator* aArena);
  76   ~CategoryNode();
  77   void operator delete(void*) {}
  78
  79   size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf);
  80
  81  private:
  82   CategoryNode() : mLock("CategoryLeaf") {}
  83
  84   void* operator new(size_t aSize, CategoryAllocator* aArena);
  85
  86   nsTHashtable<CategoryLeaf> mTable MOZ_GUARDED_BY(mLock);
  87   mozilla::Mutex mLock;
  88 };
  89
  90 /**
  91  * The main implementation of nsICategoryManager.
  92  *
  93  * This implementation is thread-safe.
  94  */
  95 class nsCategoryManager final : public nsICategoryManager,
  96                                 public nsIMemoryReporter {
  97  public:
  98   NS_DECL_ISUPPORTS
  99   NS_DECL_NSICATEGORYMANAGER
 100   NS_DECL_NSIMEMORYREPORTER
 101
 102   /**
 103    * Suppress or unsuppress notifications of category changes to the
 104    * observer service. This is to be used by nsComponentManagerImpl
 105    * on startup while reading the stored category list.
 106    */
 107   nsresult SuppressNotifications(bool aSuppress);
 108
 109   void AddCategoryEntry(const nsACString& aCategory, const nsACString& aKey,
 110                         const nsACString& aValue, bool aReplace,
 111                         nsACString& aOldValue);
 112
 113   void AddCategoryEntry(const nsACString& aCategory, const nsACString& aKey,
 114                         const nsACString& aValue, bool aReplace = true) {
 115     nsCString oldValue;
 116     return AddCategoryEntry(aCategory, aKey, aValue, aReplace, oldValue);
 117   }
 118
 119   static nsresult Create(REFNSIID aIID, void** aResult);
 120   void InitMemoryReporter();
 121
 122   static nsCategoryManager* GetSingleton();
 123   static void Destroy();
 124
 125  private:
 126   static nsCategoryManager* gCategoryManager;
 127
 128   nsCategoryManager();
 129   ~nsCategoryManager();
 130
 131   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
 132
 133   CategoryNode* get_category(const nsACString& aName) MOZ_REQUIRES(mLock);
 134   void NotifyObservers(
 135       const char* aTopic,
 136       const nsACString& aCategoryName,  // must be a static string
 137       const nsACString& aEntryName);
 138
 139   CategoryAllocator mArena;  // Mainthread only
 140   nsClassHashtable<nsDepCharHashKey, CategoryNode> mTable MOZ_GUARDED_BY(mLock);
 141   mozilla::Mutex mLock;
 142   bool mSuppressNotifications;  // Mainthread only
 143 };
 144
 145 #endif