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