xpcom/components/nsCategoryManager.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #define PL_ARENA_CONST_ALIGN_MASK 7
   7
   8 #include "nsICategoryManager.h"
   9 #include "nsCategoryManager.h"
  10
  11 #include "plarena.h"
  12 #include "prio.h"
  13 #include "prprf.h"
  14 #include "prlock.h"
  15 #include "nsCOMPtr.h"
  16 #include "nsTHashtable.h"
  17 #include "nsClassHashtable.h"
  18 #include "nsIFactory.h"
  19 #include "nsIStringEnumerator.h"
  20 #include "nsIMemoryReporter.h"
  21 #include "nsSupportsPrimitives.h"
  22 #include "nsComponentManagerUtils.h"
  23 #include "nsServiceManagerUtils.h"
  24 #include "nsIObserver.h"
  25 #include "nsIObserverService.h"
  26 #include "nsReadableUtils.h"
  27 #include "nsCRT.h"
  28 #include "nsQuickSort.h"
  29 #include "nsEnumeratorUtils.h"
  30 #include "nsThreadUtils.h"
  31 #include "mozilla/Services.h"
  32
  33 #include "ManifestParser.h"
  34
  35 using namespace mozilla;
  36 class nsIComponentLoaderManager;
  37
  38 /*
  39   CategoryDatabase
  40   contains 0 or more 1-1 mappings of string to Category
  41   each Category contains 0 or more 1-1 mappings of string keys to string values
  42
  43   In other words, the CategoryDatabase is a tree, whose root is a hashtable.
  44   Internal nodes (or Categories) are hashtables. Leaf nodes are strings.
  45
  46   The leaf strings are allocated in an arena, because we assume they're not
  47   going to change much ;)
  48 */
  49
  50 #define NS_CATEGORYMANAGER_ARENA_SIZE (1024 * 8)
  51
  52 // pulled in from nsComponentManager.cpp
  53 char* ArenaStrdup(const char* s, PLArenaPool* aArena);
  54
  55 //
  56 // BaseStringEnumerator is subclassed by EntryEnumerator and
  57 // CategoryEnumerator
  58 //
  59 class BaseStringEnumerator
  60   : public nsISimpleEnumerator,
  61     private nsIUTF8StringEnumerator
  62 {
  63 public:
  64   NS_DECL_ISUPPORTS
  65   NS_DECL_NSISIMPLEENUMERATOR
  66   NS_DECL_NSIUTF8STRINGENUMERATOR
  67
  68 protected:
  69   // Callback function for NS_QuickSort to sort mArray
  70   static int SortCallback(const void *, const void *, void *);
  71
  72   BaseStringEnumerator()
  73     : mArray(nullptr),
  74       mCount(0),
  75       mSimpleCurItem(0),
  76       mStringCurItem(0) { }
  77
  78   // A virtual destructor is needed here because subclasses of
  79   // BaseStringEnumerator do not implement their own Release() method.
  80
  81   virtual ~BaseStringEnumerator()
  82   {
  83     if (mArray)
  84       delete[] mArray;
  85   }
  86
  87   void Sort();
  88
  89   const char** mArray;
  90   uint32_t mCount;
  91   uint32_t mSimpleCurItem;
  92   uint32_t mStringCurItem;
  93 };
  94
  95 NS_IMPL_ISUPPORTS2(BaseStringEnumerator, nsISimpleEnumerator, nsIUTF8StringEnumerator)
  96
  97 NS_IMETHODIMP
  98 BaseStringEnumerator::HasMoreElements(bool *_retval)
  99 {
 100   *_retval = (mSimpleCurItem < mCount);
 101
 102   return NS_OK;
 103 }
 104
 105 NS_IMETHODIMP
 106 BaseStringEnumerator::GetNext(nsISupports **_retval)
 107 {
 108   if (mSimpleCurItem >= mCount)
 109     return NS_ERROR_FAILURE;
 110
 111   nsSupportsDependentCString* str =
 112     new nsSupportsDependentCString(mArray[mSimpleCurItem++]);
 113   if (!str)
 114     return NS_ERROR_OUT_OF_MEMORY;
 115
 116   *_retval = str;
 117   NS_ADDREF(*_retval);
 118   return NS_OK;
 119 }
 120
 121 NS_IMETHODIMP
 122 BaseStringEnumerator::HasMore(bool *_retval)
 123 {
 124   *_retval = (mStringCurItem < mCount);
 125
 126   return NS_OK;
 127 }
 128
 129 NS_IMETHODIMP
 130 BaseStringEnumerator::GetNext(nsACString& _retval)
 131 {
 132   if (mStringCurItem >= mCount)
 133     return NS_ERROR_FAILURE;
 134
 135   _retval = nsDependentCString(mArray[mStringCurItem++]);
 136   return NS_OK;
 137 }
 138
 139 int
 140 BaseStringEnumerator::SortCallback(const void *e1, const void *e2,
 141                                    void * /*unused*/)
 142 {
 143   char const *const *s1 = reinterpret_cast<char const *const *>(e1);
 144   char const *const *s2 = reinterpret_cast<char const *const *>(e2);
 145
 146   return strcmp(*s1, *s2);
 147 }
 148
 149 void
 150 BaseStringEnumerator::Sort()
 151 {
 152   NS_QuickSort(mArray, mCount, sizeof(mArray[0]), SortCallback, nullptr);
 153 }
 154
 155 //
 156 // EntryEnumerator is the wrapper that allows nsICategoryManager::EnumerateCategory
 157 //
 158 class EntryEnumerator
 159   : public BaseStringEnumerator
 160 {
 161 public:
 162   static EntryEnumerator* Create(nsTHashtable<CategoryLeaf>& aTable);
 163
 164 private:
 165   static PLDHashOperator
 166     enumfunc_createenumerator(CategoryLeaf* aLeaf, void* userArg);
 167 };
 168
 169
 170 PLDHashOperator
 171 EntryEnumerator::enumfunc_createenumerator(CategoryLeaf* aLeaf, void* userArg)
 172 {
 173   EntryEnumerator* mythis = static_cast<EntryEnumerator*>(userArg);
 174   if (aLeaf->value)
 175     mythis->mArray[mythis->mCount++] = aLeaf->GetKey();
 176
 177   return PL_DHASH_NEXT;
 178 }
 179
 180 EntryEnumerator*
 181 EntryEnumerator::Create(nsTHashtable<CategoryLeaf>& aTable)
 182 {
 183   EntryEnumerator* enumObj = new EntryEnumerator();
 184   if (!enumObj)
 185     return nullptr;
 186
 187   enumObj->mArray = new char const* [aTable.Count()];
 188   if (!enumObj->mArray) {
 189     delete enumObj;
 190     return nullptr;
 191   }
 192
 193   aTable.EnumerateEntries(enumfunc_createenumerator, enumObj);
 194
 195   enumObj->Sort();
 196
 197   return enumObj;
 198 }
 199
 200
 201 //
 202 // CategoryNode implementations
 203 //
 204
 205 CategoryNode*
 206 CategoryNode::Create(PLArenaPool* aArena)
 207 {
 208   CategoryNode* node = new(aArena) CategoryNode();
 209   if (!node)
 210     return nullptr;
 211
 212   node->mTable.Init();
 213   return node;
 214 }
 215
 216 CategoryNode::~CategoryNode()
 217 {
 218 }
 219
 220 void*
 221 CategoryNode::operator new(size_t aSize, PLArenaPool* aArena)
 222 {
 223   void* p;
 224   PL_ARENA_ALLOCATE(p, aArena, aSize);
 225   return p;
 226 }
 227
 228 NS_METHOD
 229 CategoryNode::GetLeaf(const char* aEntryName,
 230                       char** _retval)
 231 {
 232   MutexAutoLock lock(mLock);
 233   nsresult rv = NS_ERROR_NOT_AVAILABLE;
 234   CategoryLeaf* ent =
 235     mTable.GetEntry(aEntryName);
 236
 237   if (ent && ent->value) {
 238     *_retval = NS_strdup(ent->value);
 239     if (*_retval)
 240       rv = NS_OK;
 241   }
 242
 243   return rv;
 244 }
 245
 246 NS_METHOD
 247 CategoryNode::AddLeaf(const char* aEntryName,
 248                       const char* aValue,
 249                       bool aReplace,
 250                       char** _retval,
 251                       PLArenaPool* aArena)
 252 {
 253   if (_retval)
 254     *_retval = NULL;
 255
 256   MutexAutoLock lock(mLock);
 257   CategoryLeaf* leaf =
 258     mTable.GetEntry(aEntryName);
 259
 260   if (!leaf) {
 261     const char* arenaEntryName = ArenaStrdup(aEntryName, aArena);
 262     if (!arenaEntryName)
 263       return NS_ERROR_OUT_OF_MEMORY;
 264
 265     leaf = mTable.PutEntry(arenaEntryName);
 266     if (!leaf)
 267       return NS_ERROR_OUT_OF_MEMORY;
 268   }
 269
 270   if (leaf->value && !aReplace)
 271     return NS_ERROR_INVALID_ARG;
 272
 273   const char* arenaValue = ArenaStrdup(aValue, aArena);
 274   if (!arenaValue)
 275     return NS_ERROR_OUT_OF_MEMORY;
 276
 277   if (_retval && leaf->value) {
 278     *_retval = ToNewCString(nsDependentCString(leaf->value));
 279     if (!*_retval)
 280       return NS_ERROR_OUT_OF_MEMORY;
 281   }
 282
 283   leaf->value = arenaValue;
 284   return NS_OK;
 285 }
 286
 287 void
 288 CategoryNode::DeleteLeaf(const char* aEntryName)
 289 {
 290   // we don't throw any errors, because it normally doesn't matter
 291   // and it makes JS a lot cleaner
 292   MutexAutoLock lock(mLock);
 293
 294   // we can just remove the entire hash entry without introspection
 295   mTable.RemoveEntry(aEntryName);
 296 }
 297
 298 NS_METHOD
 299 CategoryNode::Enumerate(nsISimpleEnumerator **_retval)
 300 {
 301   NS_ENSURE_ARG_POINTER(_retval);
 302
 303   MutexAutoLock lock(mLock);
 304   EntryEnumerator* enumObj = EntryEnumerator::Create(mTable);
 305
 306   if (!enumObj)
 307     return NS_ERROR_OUT_OF_MEMORY;
 308
 309   *_retval = enumObj;
 310   NS_ADDREF(*_retval);
 311   return NS_OK;
 312 }
 313
 314 size_t
 315 CategoryNode::SizeOfExcludingThis(nsMallocSizeOfFun aMallocSizeOf)
 316 {
 317     // We don't measure the strings pointed to by the entries because the
 318     // pointers are non-owning.
 319     return mTable.SizeOfExcludingThis(nullptr, aMallocSizeOf);
 320 }
 321
 322 struct persistent_userstruct {
 323   PRFileDesc* fd;
 324   const char* categoryName;
 325   bool        success;
 326 };
 327
 328 PLDHashOperator
 329 enumfunc_pentries(CategoryLeaf* aLeaf, void* userArg)
 330 {
 331   persistent_userstruct* args =
 332     static_cast<persistent_userstruct*>(userArg);
 333
 334   PLDHashOperator status = PL_DHASH_NEXT;
 335
 336   if (aLeaf->value) {
 337     if (PR_fprintf(args->fd,
 338                    "%s,%s,%s\n",
 339                    args->categoryName,
 340                    aLeaf->GetKey(),
 341                    aLeaf->value) == (uint32_t) -1) {
 342       args->success = false;
 343       status = PL_DHASH_STOP;
 344     }
 345   }
 346
 347   return status;
 348 }
 349
 350 //
 351 // CategoryEnumerator class
 352 //
 353
 354 class CategoryEnumerator
 355   : public BaseStringEnumerator
 356 {
 357 public:
 358   static CategoryEnumerator* Create(nsClassHashtable<nsDepCharHashKey, CategoryNode>& aTable);
 359
 360 private:
 361   static PLDHashOperator
 362   enumfunc_createenumerator(const char* aStr,
 363                             CategoryNode* aNode,
 364                             void* userArg);
 365 };
 366
 367 CategoryEnumerator*
 368 CategoryEnumerator::Create(nsClassHashtable<nsDepCharHashKey, CategoryNode>& aTable)
 369 {
 370   CategoryEnumerator* enumObj = new CategoryEnumerator();
 371   if (!enumObj)
 372     return nullptr;
 373
 374   enumObj->mArray = new const char* [aTable.Count()];
 375   if (!enumObj->mArray) {
 376     delete enumObj;
 377     return nullptr;
 378   }
 379
 380   aTable.EnumerateRead(enumfunc_createenumerator, enumObj);
 381
 382   return enumObj;
 383 }
 384
 385 PLDHashOperator
 386 CategoryEnumerator::enumfunc_createenumerator(const char* aStr, CategoryNode* aNode, void* userArg)
 387 {
 388   CategoryEnumerator* mythis = static_cast<CategoryEnumerator*>(userArg);
 389
 390   // if a category has no entries, we pretend it doesn't exist
 391   if (aNode->Count())
 392     mythis->mArray[mythis->mCount++] = aStr;
 393
 394   return PL_DHASH_NEXT;
 395 }
 396
 397
 398 //
 399 // nsCategoryManager implementations
 400 //
 401
 402 NS_IMPL_QUERY_INTERFACE1(nsCategoryManager, nsICategoryManager)
 403
 404 NS_MEMORY_REPORTER_MALLOC_SIZEOF_FUN(CategoryManagerMallocSizeOf)
 405
 406 NS_MEMORY_REPORTER_IMPLEMENT(CategoryManager,
 407     "explicit/xpcom/category-manager",
 408     KIND_HEAP,
 409     nsIMemoryReporter::UNITS_BYTES,
 410     nsCategoryManager::GetCategoryManagerSize,
 411     "Memory used for the XPCOM category manager.")
 412
 413 NS_IMETHODIMP_(nsrefcnt)
 414 nsCategoryManager::AddRef()
 415 {
 416   return 2;
 417 }
 418
 419 NS_IMETHODIMP_(nsrefcnt)
 420 nsCategoryManager::Release()
 421 {
 422   return 1;
 423 }
 424
 425 nsCategoryManager* nsCategoryManager::gCategoryManager;
 426
 427 /* static */ nsCategoryManager*
 428 nsCategoryManager::GetSingleton()
 429 {
 430   if (!gCategoryManager)
 431     gCategoryManager = new nsCategoryManager();
 432   return gCategoryManager;
 433 }
 434
 435 /* static */ void
 436 nsCategoryManager::Destroy()
 437 {
 438   delete gCategoryManager;
 439   gCategoryManager = nullptr;
 440 }
 441
 442 nsresult
 443 nsCategoryManager::Create(nsISupports* aOuter, REFNSIID aIID, void** aResult)
 444 {
 445   if (aOuter)
 446     return NS_ERROR_NO_AGGREGATION;
 447
 448   return GetSingleton()->QueryInterface(aIID, aResult);
 449 }
 450
 451 nsCategoryManager::nsCategoryManager()
 452   : mLock("nsCategoryManager")
 453   , mSuppressNotifications(false)
 454   , mReporter(nullptr)
 455 {
 456   PL_INIT_ARENA_POOL(&mArena, "CategoryManagerArena",
 457                      NS_CATEGORYMANAGER_ARENA_SIZE);
 458
 459   mTable.Init();
 460 }
 461
 462 void
 463 nsCategoryManager::InitMemoryReporter()
 464 {
 465   mReporter = new NS_MEMORY_REPORTER_NAME(CategoryManager);
 466   NS_RegisterMemoryReporter(mReporter);
 467 }
 468
 469 nsCategoryManager::~nsCategoryManager()
 470 {
 471   (void)::NS_UnregisterMemoryReporter(mReporter);
 472   mReporter = nullptr;
 473
 474   // the hashtable contains entries that must be deleted before the arena is
 475   // destroyed, or else you will have PRLocks undestroyed and other Really
 476   // Bad Stuff (TM)
 477   mTable.Clear();
 478
 479   PL_FinishArenaPool(&mArena);
 480 }
 481
 482 inline CategoryNode*
 483 nsCategoryManager::get_category(const char* aName) {
 484   CategoryNode* node;
 485   if (!mTable.Get(aName, &node)) {
 486     return nullptr;
 487   }
 488   return node;
 489 }
 490
 491 /* static */ int64_t
 492 nsCategoryManager::GetCategoryManagerSize()
 493 {
 494   MOZ_ASSERT(nsCategoryManager::gCategoryManager);
 495   return nsCategoryManager::gCategoryManager->SizeOfIncludingThis(
 496            CategoryManagerMallocSizeOf);
 497 }
 498
 499 static size_t
 500 SizeOfCategoryManagerTableEntryExcludingThis(nsDepCharHashKey::KeyType aKey,
 501                                              const nsAutoPtr<CategoryNode> &aData,
 502                                              nsMallocSizeOfFun aMallocSizeOf,
 503                                              void* aUserArg)
 504 {
 505     // We don't measure the string pointed to by aKey because it's a non-owning
 506     // pointer.
 507     return aData.get()->SizeOfExcludingThis(aMallocSizeOf);
 508 }
 509
 510 size_t
 511 nsCategoryManager::SizeOfIncludingThis(nsMallocSizeOfFun aMallocSizeOf)
 512 {
 513   size_t n = aMallocSizeOf(this);
 514
 515   n += PL_SizeOfArenaPoolExcludingPool(&mArena, aMallocSizeOf);
 516
 517   n += mTable.SizeOfExcludingThis(SizeOfCategoryManagerTableEntryExcludingThis,
 518                                   aMallocSizeOf);
 519
 520   return n;
 521 }
 522
 523 namespace {
 524
 525 class CategoryNotificationRunnable : public nsRunnable
 526 {
 527 public:
 528   CategoryNotificationRunnable(nsISupports* aSubject,
 529                                const char* aTopic,
 530                                const char* aData)
 531     : mSubject(aSubject)
 532     , mTopic(aTopic)
 533     , mData(aData)
 534   { }
 535
 536   NS_DECL_NSIRUNNABLE
 537
 538 private:
 539   nsCOMPtr<nsISupports> mSubject;
 540   const char* mTopic;
 541   NS_ConvertUTF8toUTF16 mData;
 542 };
 543
 544 NS_IMETHODIMP
 545 CategoryNotificationRunnable::Run()
 546 {
 547   nsCOMPtr<nsIObserverService> observerService =
 548     mozilla::services::GetObserverService();
 549   if (observerService)
 550     observerService->NotifyObservers(mSubject, mTopic, mData.get());
 551
 552   return NS_OK;
 553 }
 554
 555 } // anonymous namespace
 556
 557
 558 void
 559 nsCategoryManager::NotifyObservers( const char *aTopic,
 560                                     const char *aCategoryName,
 561                                     const char *aEntryName )
 562 {
 563   if (mSuppressNotifications)
 564     return;
 565
 566   nsRefPtr<CategoryNotificationRunnable> r;
 567
 568   if (aEntryName) {
 569     nsCOMPtr<nsISupportsCString> entry
 570       (do_CreateInstance (NS_SUPPORTS_CSTRING_CONTRACTID));
 571     if (!entry)
 572       return;
 573
 574     nsresult rv = entry->SetData(nsDependentCString(aEntryName));
 575     if (NS_FAILED(rv))
 576       return;
 577
 578     r = new CategoryNotificationRunnable(entry, aTopic, aCategoryName);
 579   } else {
 580     r = new CategoryNotificationRunnable(this, aTopic, aCategoryName);
 581   }
 582
 583   NS_DispatchToMainThread(r);
 584 }
 585
 586 NS_IMETHODIMP
 587 nsCategoryManager::GetCategoryEntry( const char *aCategoryName,
 588                                      const char *aEntryName,
 589                                      char **_retval )
 590 {
 591   NS_ENSURE_ARG_POINTER(aCategoryName);
 592   NS_ENSURE_ARG_POINTER(aEntryName);
 593   NS_ENSURE_ARG_POINTER(_retval);
 594
 595   nsresult status = NS_ERROR_NOT_AVAILABLE;
 596
 597   CategoryNode* category;
 598   {
 599     MutexAutoLock lock(mLock);
 600     category = get_category(aCategoryName);
 601   }
 602
 603   if (category) {
 604     status = category->GetLeaf(aEntryName, _retval);
 605   }
 606
 607   return status;
 608 }
 609
 610 NS_IMETHODIMP
 611 nsCategoryManager::AddCategoryEntry( const char *aCategoryName,
 612                                      const char *aEntryName,
 613                                      const char *aValue,
 614                                      bool aPersist,
 615                                      bool aReplace,
 616                                      char **_retval )
 617 {
 618   if (aPersist) {
 619     NS_ERROR("Category manager doesn't support persistence.");
 620     return NS_ERROR_INVALID_ARG;
 621   }
 622
 623   AddCategoryEntry(aCategoryName, aEntryName, aValue, aReplace, _retval);
 624   return NS_OK;
 625 }
 626
 627 void
 628 nsCategoryManager::AddCategoryEntry(const char *aCategoryName,
 629                                     const char *aEntryName,
 630                                     const char *aValue,
 631                                     bool aReplace,
 632                                     char** aOldValue)
 633 {
 634   if (aOldValue)
 635     *aOldValue = NULL;
 636
 637   // Before we can insert a new entry, we'll need to
 638   //  find the |CategoryNode| to put it in...
 639   CategoryNode* category;
 640   {
 641     MutexAutoLock lock(mLock);
 642     category = get_category(aCategoryName);
 643
 644     if (!category) {
 645       // That category doesn't exist yet; let's make it.
 646       category = CategoryNode::Create(&mArena);
 647
 648       char* categoryName = ArenaStrdup(aCategoryName, &mArena);
 649       mTable.Put(categoryName, category);
 650     }
 651   }
 652
 653   if (!category)
 654     return;
 655
 656   // We will need the return value of AddLeaf even if the called doesn't want it
 657   char *oldEntry = nullptr;
 658
 659   nsresult rv = category->AddLeaf(aEntryName,
 660                                   aValue,
 661                                   aReplace,
 662                                   &oldEntry,
 663                                   &mArena);
 664
 665   if (NS_SUCCEEDED(rv)) {
 666     if (oldEntry) {
 667       NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_REMOVED_OBSERVER_ID,
 668                       aCategoryName, oldEntry);
 669     }
 670     NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_ADDED_OBSERVER_ID,
 671                     aCategoryName, aEntryName);
 672
 673     if (aOldValue)
 674       *aOldValue = oldEntry;
 675     else
 676       NS_Free(oldEntry);
 677   }
 678 }
 679
 680 NS_IMETHODIMP
 681 nsCategoryManager::DeleteCategoryEntry( const char *aCategoryName,
 682                                         const char *aEntryName,
 683                                         bool aDontPersist)
 684 {
 685   NS_ENSURE_ARG_POINTER(aCategoryName);
 686   NS_ENSURE_ARG_POINTER(aEntryName);
 687
 688   /*
 689     Note: no errors are reported since failure to delete
 690     probably won't hurt you, and returning errors seriously
 691     inconveniences JS clients
 692   */
 693
 694   CategoryNode* category;
 695   {
 696     MutexAutoLock lock(mLock);
 697     category = get_category(aCategoryName);
 698   }
 699
 700   if (category) {
 701     category->DeleteLeaf(aEntryName);
 702
 703     NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_REMOVED_OBSERVER_ID,
 704                     aCategoryName, aEntryName);
 705   }
 706
 707   return NS_OK;
 708 }
 709
 710 NS_IMETHODIMP
 711 nsCategoryManager::DeleteCategory( const char *aCategoryName )
 712 {
 713   NS_ENSURE_ARG_POINTER(aCategoryName);
 714
 715   // the categories are arena-allocated, so we don't
 716   // actually delete them. We just remove all of the
 717   // leaf nodes.
 718
 719   CategoryNode* category;
 720   {
 721     MutexAutoLock lock(mLock);
 722     category = get_category(aCategoryName);
 723   }
 724
 725   if (category) {
 726     category->Clear();
 727     NotifyObservers(NS_XPCOM_CATEGORY_CLEARED_OBSERVER_ID,
 728                     aCategoryName, nullptr);
 729   }
 730
 731   return NS_OK;
 732 }
 733
 734 NS_IMETHODIMP
 735 nsCategoryManager::EnumerateCategory( const char *aCategoryName,
 736                                       nsISimpleEnumerator **_retval )
 737 {
 738   NS_ENSURE_ARG_POINTER(aCategoryName);
 739   NS_ENSURE_ARG_POINTER(_retval);
 740
 741   CategoryNode* category;
 742   {
 743     MutexAutoLock lock(mLock);
 744     category = get_category(aCategoryName);
 745   }
 746
 747   if (!category) {
 748     return NS_NewEmptyEnumerator(_retval);
 749   }
 750
 751   return category->Enumerate(_retval);
 752 }
 753
 754 NS_IMETHODIMP
 755 nsCategoryManager::EnumerateCategories(nsISimpleEnumerator **_retval)
 756 {
 757   NS_ENSURE_ARG_POINTER(_retval);
 758
 759   MutexAutoLock lock(mLock);
 760   CategoryEnumerator* enumObj = CategoryEnumerator::Create(mTable);
 761
 762   if (!enumObj)
 763     return NS_ERROR_OUT_OF_MEMORY;
 764
 765   *_retval = enumObj;
 766   NS_ADDREF(*_retval);
 767   return NS_OK;
 768 }
 769
 770 struct writecat_struct {
 771   PRFileDesc* fd;
 772   bool        success;
 773 };
 774
 775 NS_METHOD
 776 nsCategoryManager::SuppressNotifications(bool aSuppress)
 777 {
 778   mSuppressNotifications = aSuppress;
 779   return NS_OK;
 780 }
 781
 782 /*
 783  * CreateServicesFromCategory()
 784  *
 785  * Given a category, this convenience functions enumerates the category and
 786  * creates a service of every CID or ContractID registered under the category.
 787  * If observerTopic is non null and the service implements nsIObserver,
 788  * this will attempt to notify the observer with the origin, observerTopic string
 789  * as parameter.
 790  */
 791 void
 792 NS_CreateServicesFromCategory(const char *category,
 793                               nsISupports *origin,
 794                               const char *observerTopic)
 795 {
 796   nsresult rv;
 797
 798   nsCOMPtr<nsICategoryManager> categoryManager =
 799     do_GetService("@mozilla.org/categorymanager;1");
 800   if (!categoryManager)
 801     return;
 802
 803   nsCOMPtr<nsISimpleEnumerator> enumerator;
 804   rv = categoryManager->EnumerateCategory(category,
 805                                           getter_AddRefs(enumerator));
 806   if (NS_FAILED(rv))
 807     return;
 808
 809   nsCOMPtr<nsIUTF8StringEnumerator> senumerator =
 810     do_QueryInterface(enumerator);
 811   if (!senumerator) {
 812     NS_WARNING("Category enumerator doesn't support nsIUTF8StringEnumerator.");
 813     return;
 814   }
 815
 816   bool hasMore;
 817   while (NS_SUCCEEDED(senumerator->HasMore(&hasMore)) && hasMore) {
 818     // From here on just skip any error we get.
 819     nsAutoCString entryString;
 820     if (NS_FAILED(senumerator->GetNext(entryString)))
 821       continue;
 822
 823     nsXPIDLCString contractID;
 824     rv = categoryManager->GetCategoryEntry(category,entryString.get(),
 825                                            getter_Copies(contractID));
 826     if (NS_FAILED(rv))
 827       continue;
 828
 829     nsCOMPtr<nsISupports> instance = do_GetService(contractID);
 830     if (!instance) {
 831       LogMessage("While creating services from category '%s', could not create service for entry '%s', contract ID '%s'",
 832                  category, entryString.get(), contractID.get());
 833       continue;
 834     }
 835
 836     if (observerTopic) {
 837       // try an observer, if it implements it.
 838       nsCOMPtr<nsIObserver> observer = do_QueryInterface(instance);
 839       if (observer)
 840         observer->Observe(origin, observerTopic, EmptyString().get());
 841       else
 842         LogMessage("While creating services from category '%s', service for entry '%s', contract ID '%s' does not implement nsIObserver.",
 843                    category, entryString.get(), contractID.get());
 844     }
 845   }
 846 }