From 119bbaf72945d928b47fad6437923b4e77417d02 Mon Sep 17 00:00:00 2001 From: "darin%meer.net" Date: Thu, 9 Mar 2006 03:14:32 +0000 Subject: [PATCH] backing out bsmedberg's patch for bug 326491 to fix bug 329505. git-svn-id: svn://10.0.0.236/trunk@192045 18797224-902f-48f8-a5cc-f745e15eee43 --- mozilla/docshell/base/nsDocShell.cpp | 1 + mozilla/xpcom/build/nsXPCOMCID.h | 7 - mozilla/xpcom/build/nsXPComInit.cpp | 10 +- mozilla/xpcom/ds/Makefile.in | 1 + mozilla/xpcom/ds/nsObserverList.cpp | 151 +++++++------ mozilla/xpcom/ds/nsObserverList.h | 81 +------ mozilla/xpcom/ds/nsObserverService.cpp | 202 ++++++++++++------ mozilla/xpcom/ds/nsObserverService.h | 20 +- mozilla/xpcom/glue/nsTArray.h | 14 +- .../windowds/nsWindowDataSource.cpp | 3 +- 10 files changed, 242 insertions(+), 248 deletions(-) diff --git a/mozilla/docshell/base/nsDocShell.cpp b/mozilla/docshell/base/nsDocShell.cpp index 966e03718b6..409080ebb63 100644 --- a/mozilla/docshell/base/nsDocShell.cpp +++ b/mozilla/docshell/base/nsDocShell.cpp @@ -93,6 +93,7 @@ #include "nsIPrefBranch.h" #include "nsIPrefBranch2.h" #include "nsIWritablePropertyBag2.h" +#include "nsObserverService.h" // we want to explore making the document own the load group // so we can associate the document URI with the load group. diff --git a/mozilla/xpcom/build/nsXPCOMCID.h b/mozilla/xpcom/build/nsXPCOMCID.h index 26299091d0b..4920322c401 100644 --- a/mozilla/xpcom/build/nsXPCOMCID.h +++ b/mozilla/xpcom/build/nsXPCOMCID.h @@ -84,13 +84,6 @@ */ #define NS_ARRAY_CONTRACTID "@mozilla.org/array;1" -/** - * Observer Service ContractID - * The observer service implements the global nsIObserverService object. - * It should be used from the main thread only. - */ -#define NS_OBSERVERSERVICE_CONTRACTID "@mozilla.org/observer-service;1" - /** * The following are the CIDs and Contract IDs of the nsISupports wrappers for * primative types. diff --git a/mozilla/xpcom/build/nsXPComInit.cpp b/mozilla/xpcom/build/nsXPComInit.cpp index 68758375b4b..ff91d4baa89 100644 --- a/mozilla/xpcom/build/nsXPComInit.cpp +++ b/mozilla/xpcom/build/nsXPComInit.cpp @@ -681,9 +681,8 @@ NS_ShutdownXPCOM(nsIServiceManager* servMgr) nsCOMPtr currentQ; NS_GetCurrentEventQ(getter_AddRefs(currentQ), eqs); - nsRefPtr observerService; - CallGetService("@mozilla.org/observer-service;1", - (nsObserverService**) getter_AddRefs(observerService)); + nsCOMPtr observerService = + do_GetService("@mozilla.org/observer-service;1"); if (observerService) { @@ -722,13 +721,10 @@ NS_ShutdownXPCOM(nsIServiceManager* servMgr) // We save the "xpcom-shutdown-loaders" observers to notify after // the observerservice is gone. - if (observerService) { + if (observerService) observerService-> EnumerateObservers(NS_XPCOM_SHUTDOWN_LOADERS_OBSERVER_ID, getter_AddRefs(moduleLoaders)); - - observerService->Shutdown(); - } } // XPCOM is officially in shutdown mode NOW diff --git a/mozilla/xpcom/ds/Makefile.in b/mozilla/xpcom/ds/Makefile.in index b8ca623062b..95f4d815e5c 100644 --- a/mozilla/xpcom/ds/Makefile.in +++ b/mozilla/xpcom/ds/Makefile.in @@ -99,6 +99,7 @@ EXPORTS = \ nsIByteBuffer.h \ nsIUnicharBuffer.h \ nsInt64.h \ + nsObserverService.h \ nsRecyclingAllocator.h \ nsStaticNameTable.h \ nsStaticAtom.h \ diff --git a/mozilla/xpcom/ds/nsObserverList.cpp b/mozilla/xpcom/ds/nsObserverList.cpp index 526c2880103..6a85f8acaca 100644 --- a/mozilla/xpcom/ds/nsObserverList.cpp +++ b/mozilla/xpcom/ds/nsObserverList.cpp @@ -37,29 +37,53 @@ #include "nsObserverList.h" +#include "pratom.h" +#include "nsAutoLock.h" #include "nsAutoPtr.h" -#include "nsCOMArray.h" +#include "nsCOMPtr.h" +#include "nsIObserver.h" #include "nsISimpleEnumerator.h" +#include "nsIWeakReference.h" + +nsObserverList::nsObserverList(nsresult &rv) +{ + MOZ_COUNT_CTOR(nsObserverList); + mLock = PR_NewLock(); + if (!mLock) + rv = NS_ERROR_OUT_OF_MEMORY; +} + +nsObserverList::~nsObserverList(void) +{ + MOZ_COUNT_DTOR(nsObserverList); + if (mLock) + PR_DestroyLock(mLock); +} nsresult nsObserverList::AddObserver(nsIObserver* anObserver, PRBool ownsWeak) { - NS_ASSERTION(anObserver, "Null input"); + NS_ENSURE_ARG(anObserver); - if (!ownsWeak) { - ObserverRef* o = mObservers.AppendElement(anObserver); - if (!o) - return NS_ERROR_OUT_OF_MEMORY; + nsAutoLock lock(mLock); - return NS_OK; + nsCOMPtr observerRef; + if (ownsWeak) { + nsCOMPtr + weakRefFactory(do_QueryInterface(anObserver)); + NS_ASSERTION(weakRefFactory, + "Doesn't implement nsISupportsWeakReference"); + if (weakRefFactory) + weakRefFactory-> + GetWeakReference((nsIWeakReference**)(nsISupports**) + getter_AddRefs(observerRef)); + } else { + observerRef = anObserver; } - - nsCOMPtr weak = do_GetWeakReference(anObserver); - if (!weak) - return NS_NOINTERFACE; + if (!observerRef) + return NS_ERROR_FAILURE; - ObserverRef *o = mObservers.AppendElement(weak); - if (!o) + if (!mObservers.AppendObject(observerRef)) return NS_ERROR_OUT_OF_MEMORY; return NS_OK; @@ -68,25 +92,51 @@ nsObserverList::AddObserver(nsIObserver* anObserver, PRBool ownsWeak) nsresult nsObserverList::RemoveObserver(nsIObserver* anObserver) { - NS_ASSERTION(anObserver, "Null input"); + NS_ENSURE_ARG(anObserver); - if (mObservers.RemoveElement(NS_STATIC_CAST(nsISupports*, anObserver))) + nsAutoLock lock(mLock); + + if (mObservers.RemoveObject(anObserver)) return NS_OK; - nsCOMPtr observerRef = do_GetWeakReference(anObserver); + nsCOMPtr + weakRefFactory(do_QueryInterface(anObserver)); + if (!weakRefFactory) + return NS_ERROR_FAILURE; + + nsCOMPtr observerRef; + weakRefFactory->GetWeakReference(getter_AddRefs(observerRef)); + if (!observerRef) return NS_ERROR_FAILURE; - if (!mObservers.RemoveElement(observerRef)) + if (!mObservers.RemoveObject(observerRef)) return NS_ERROR_FAILURE; return NS_OK; } +class nsObserverEnumerator : public nsISimpleEnumerator +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSISIMPLEENUMERATOR + + nsObserverEnumerator(nsCOMArray &aObservers); + +private: + ~nsObserverEnumerator() { } + + PRUint32 mIndex; // Counts down, ends at 0 + nsCOMArray mObservers; +}; + nsresult nsObserverList::GetObserverList(nsISimpleEnumerator** anEnumerator) { - nsRefPtr e(new nsObserverEnumerator(this)); + nsAutoLock lock(mLock); + + nsRefPtr e(new nsObserverEnumerator(mObservers)); if (!e) return NS_ERROR_OUT_OF_MEMORY; @@ -94,82 +144,41 @@ nsObserverList::GetObserverList(nsISimpleEnumerator** anEnumerator) return NS_OK; } -void -nsObserverList::EnumerateObservers(EnumObserversFunc aFunc, void *aClosure) +nsObserverEnumerator::nsObserverEnumerator(nsCOMArray &aObservers) { - for (PRInt32 i = mObservers.Length() - 1; i >= 0; --i) { - if (mObservers[i].isWeakRef) { - nsCOMPtr o(do_QueryReferent(mObservers[i].asWeak())); - if (o) { - aFunc(o, aClosure); - } - else { - // the object has gone away, remove the weakref - mObservers.RemoveElementAt(i); - } + for (PRInt32 i = 0; i < aObservers.Count(); ++i) { + nsCOMPtr weak(do_QueryInterface(aObservers[i])); + if (weak) { + nsCOMPtr strong(do_QueryReferent(weak)); + if (strong) + mObservers.AppendObject(strong); } else { - aFunc(mObservers[i].asObserver(), aClosure); + mObservers.AppendObject(aObservers[i]); } } -} -struct NotifyData -{ - nsISupports* aSubject; - const char *aTopic; - const PRUnichar *someData; -}; - -void -nsObserverList::NotifyObservers(nsISupports *aSubject, - const char *aTopic, - const PRUnichar *someData) -{ - NotifyData nd = { aSubject, aTopic, someData }; - EnumerateObservers(Notify, &nd); -} - -void -nsObserverList::Notify(nsIObserver* aObserver, void *aClosure) -{ - NotifyData *nd = NS_REINTERPRET_CAST(NotifyData*, aClosure); - aObserver->Observe(nd->aSubject, nd->aTopic, nd->someData); + mIndex = mObservers.Count(); } NS_IMPL_ISUPPORTS1(nsObserverEnumerator, nsISimpleEnumerator) -void -nsObserverEnumerator::Fill(nsIObserver* aObserver, void *aClosure) -{ - nsObserverEnumerator* e = - NS_REINTERPRET_CAST(nsObserverEnumerator*, aClosure); - e->mObservers.AppendObject(aObserver); -} - -nsObserverEnumerator::nsObserverEnumerator(nsObserverList* aObserverList) - : mIndex(0) -{ - mObservers.SetCapacity(aObserverList->mObservers.Length()); - aObserverList->EnumerateObservers(Fill, this); -} - NS_IMETHODIMP nsObserverEnumerator::HasMoreElements(PRBool *aResult) { - *aResult = (mIndex < mObservers.Count()); + *aResult = (mIndex > 0); return NS_OK; } NS_IMETHODIMP nsObserverEnumerator::GetNext(nsISupports* *aResult) { - if (mIndex == mObservers.Count()) { + if (!mIndex) { NS_ERROR("Enumerating after HasMoreElements returned false."); return NS_ERROR_UNEXPECTED; } + --mIndex; NS_ADDREF(*aResult = mObservers[mIndex]); - ++mIndex; return NS_OK; } diff --git a/mozilla/xpcom/ds/nsObserverList.h b/mozilla/xpcom/ds/nsObserverList.h index cb14aacd796..6706cae65b7 100644 --- a/mozilla/xpcom/ds/nsObserverList.h +++ b/mozilla/xpcom/ds/nsObserverList.h @@ -39,88 +39,25 @@ #define nsObserverList_h___ #include "nsISupports.h" -#include "nsTArray.h" -#include "nsCOMPtr.h" #include "nsCOMArray.h" -#include "nsIObserver.h" -#include "nsIWeakReference.h" -#include "nsHashKeys.h" -#include "nsISimpleEnumerator.h" -struct ObserverRef -{ - ObserverRef(const ObserverRef& o) : - isWeakRef(o.isWeakRef), ref(o.ref) { } - - ObserverRef(nsIObserver* aObserver) : isWeakRef(PR_FALSE), ref(aObserver) { } - ObserverRef(nsIWeakReference* aWeak) : isWeakRef(PR_TRUE), ref(aWeak) { } +class nsISimpleEnumerator; +class nsIObserver; - PRBool isWeakRef; - nsCOMPtr ref; - - nsIObserver* asObserver() { - NS_ASSERTION(!isWeakRef, "Isn't a strong ref."); - return NS_STATIC_CAST(nsIObserver*, (nsISupports*) ref); - } - - nsIWeakReference* asWeak() { - NS_ASSERTION(isWeakRef, "Isn't a weak ref."); - return NS_STATIC_CAST(nsIWeakReference*, (nsISupports*) ref); - } - - PRBool operator==(nsISupports* b) const { return ref == b; } -}; - -class nsObserverList : public nsCharPtrHashKey +class nsObserverList { public: - nsObserverList(const char *key) : nsCharPtrHashKey(key) - { MOZ_COUNT_CTOR(nsObserverList); } - - ~nsObserverList() { MOZ_COUNT_DTOR(nsObserverList); } + nsObserverList(nsresult &rv); + ~nsObserverList(); nsresult AddObserver(nsIObserver* anObserver, PRBool ownsWeak); nsresult RemoveObserver(nsIObserver* anObserver); - - void NotifyObservers(nsISupports *aSubject, - const char *aTopic, - const PRUnichar *someData); nsresult GetObserverList(nsISimpleEnumerator** anEnumerator); - -private: - friend class nsObserverEnumerator; - - typedef void (*EnumObserversFunc)(nsIObserver* aObserver, void *aClosure); - - // EnumerateObservers passes all the registered observers to aFunc - // in LIFO order. If there are any stale weak references they are - // removed during enumeration. aFunc must not modify the observerlist - // during enumeration. - void EnumerateObservers(EnumObserversFunc aFunc, void *aClosure); - - // Static helper function for NotifyObservers - static void Notify(nsIObserver* aObserver, void *aClosure); - - nsTArray mObservers; - + +protected: + PRLock* mLock; + nsCOMArray mObservers; }; -class nsObserverEnumerator : public nsISimpleEnumerator -{ -public: - NS_DECL_ISUPPORTS - NS_DECL_NSISIMPLEENUMERATOR - - nsObserverEnumerator(nsObserverList* aObserverList); - -private: - ~nsObserverEnumerator() { } - - // Static helper function for the constructor - static void Fill(nsIObserver* aObserver, void *aClosure); - - PRInt32 mIndex; // Counts up from 0 - nsCOMArray mObservers; -}; #endif /* nsObserverList_h___ */ diff --git a/mozilla/xpcom/ds/nsObserverService.cpp b/mozilla/xpcom/ds/nsObserverService.cpp index c5b11be88f9..ea93aff8c31 100644 --- a/mozilla/xpcom/ds/nsObserverService.cpp +++ b/mozilla/xpcom/ds/nsObserverService.cpp @@ -37,7 +37,7 @@ * ***** END LICENSE BLOCK ***** */ #include "prlog.h" -#include "nsAutoPtr.h" +#include "prlock.h" #include "nsIFactory.h" #include "nsIServiceManager.h" #include "nsIComponentManager.h" @@ -48,8 +48,6 @@ #include "nsObserverList.h" #include "nsHashtable.h" #include "nsIWeakReference.h" -#include "nsIThread.h" -#include "nsIEnumerator.h" #define NOTIFY_GLOBAL_OBSERVERS @@ -70,26 +68,17 @@ PRLogModuleInfo* observerServiceLog = nsnull; // nsObserverService Implementation -NS_IMPL_THREADSAFE_ISUPPORTS2(nsObserverService, nsIObserverService, nsObserverService) +NS_IMPL_THREADSAFE_ISUPPORTS1(nsObserverService, nsIObserverService) -nsObserverService::nsObserverService() : - mShuttingDown(PR_FALSE) +nsObserverService::nsObserverService() + : mObserverTopicTable(nsnull) { - mObserverTopicTable.Init(); } nsObserverService::~nsObserverService(void) { - Shutdown(); -} - -void -nsObserverService::Shutdown() -{ - mShuttingDown = PR_TRUE; - - if (mObserverTopicTable.IsInitialized()) - mObserverTopicTable.Clear(); + if(mObserverTopicTable) + delete mObserverTopicTable; } NS_METHOD @@ -100,85 +89,158 @@ nsObserverService::Create(nsISupports* outer, const nsIID& aIID, void* *aInstanc observerServiceLog = PR_NewLogModule("ObserverService"); #endif - nsRefPtr os = new nsObserverService(); - - // The cast is required for MSVC6, otherwise it complains about calling - // a private function. - if (!os || !((nsObserverService*) os)->mObserverTopicTable.IsInitialized()) + nsresult rv; + nsObserverService* os = new nsObserverService(); + if (os == nsnull) return NS_ERROR_OUT_OF_MEMORY; - - return os->QueryInterface(aIID, aInstancePtr); + NS_ADDREF(os); + rv = os->QueryInterface(aIID, aInstancePtr); + NS_RELEASE(os); + return rv; } -#define NS_ENSURE_VALIDCALL \ - if (!nsIThread::IsMainThread()) { \ - NS_ERROR("Using observer service off the main thread!"); \ - return NS_ERROR_UNEXPECTED; \ - } \ - if (mShuttingDown) { \ - NS_ERROR("Using observer service after XPCOM shutdown!"); \ - return NS_ERROR_ILLEGAL_DURING_SHUTDOWN; \ +static PRBool PR_CALLBACK +ReleaseObserverList(nsHashKey *aKey, void *aData, void* closure) +{ + nsObserverList* observerList = NS_STATIC_CAST(nsObserverList*, aData); + delete(observerList); + return PR_TRUE; +} + +nsresult nsObserverService::GetObserverList(const char* aTopic, nsObserverList** anObserverList) +{ + if (anObserverList == nsnull) + return NS_ERROR_NULL_POINTER; + + if(mObserverTopicTable == nsnull) + { + mObserverTopicTable = new nsObjectHashtable(nsnull, + nsnull, // should never be cloned + ReleaseObserverList, + nsnull, + 256, + PR_TRUE); + if (mObserverTopicTable == nsnull) + return NS_ERROR_OUT_OF_MEMORY; + } + + + nsCStringKey key(aTopic); + + nsObserverList *topicObservers; + topicObservers = (nsObserverList *) mObserverTopicTable->Get(&key); + + if (topicObservers) + { + *anObserverList = topicObservers; + return NS_OK; } -NS_IMETHODIMP -nsObserverService::AddObserver(nsIObserver* anObserver, const char* aTopic, - PRBool ownsWeak) -{ - NS_ENSURE_VALIDCALL - NS_ENSURE_ARG(anObserver && aTopic); - - nsObserverList *observerList = mObserverTopicTable.PutEntry(aTopic); - if (!observerList) + nsresult rv = NS_OK; + topicObservers = new nsObserverList(rv); + if (!topicObservers) return NS_ERROR_OUT_OF_MEMORY; - return observerList->AddObserver(anObserver, ownsWeak); + if (NS_FAILED(rv)) { + delete topicObservers; + return rv; + } + + *anObserverList = topicObservers; + mObserverTopicTable->Put(&key, topicObservers); + + return NS_OK; } -NS_IMETHODIMP -nsObserverService::RemoveObserver(nsIObserver* anObserver, const char* aTopic) +NS_IMETHODIMP nsObserverService::AddObserver(nsIObserver* anObserver, const char* aTopic, PRBool ownsWeak) { - NS_ENSURE_VALIDCALL - NS_ENSURE_ARG(anObserver && aTopic); + nsObserverList* anObserverList; + nsresult rv; - nsObserverList *observerList = mObserverTopicTable.GetEntry(aTopic); - if (!observerList) - return NS_ERROR_FAILURE; + if (anObserver == nsnull || aTopic == nsnull) + return NS_ERROR_NULL_POINTER; - return observerList->RemoveObserver(anObserver); + rv = GetObserverList(aTopic, &anObserverList); + if (NS_FAILED(rv)) return rv; + + return anObserverList->AddObserver(anObserver, ownsWeak); } -NS_IMETHODIMP -nsObserverService::EnumerateObservers(const char* aTopic, - nsISimpleEnumerator** anEnumerator) +NS_IMETHODIMP nsObserverService::RemoveObserver(nsIObserver* anObserver, const char* aTopic) { - NS_ENSURE_VALIDCALL - NS_ENSURE_ARG(aTopic && anEnumerator); + nsObserverList* anObserverList; + nsresult rv; - nsObserverList *observerList = mObserverTopicTable.GetEntry(aTopic); - if (!observerList) - return NS_NewEmptyEnumerator(anEnumerator); + if (anObserver == nsnull || aTopic == nsnull) + return NS_ERROR_NULL_POINTER; - return observerList->GetObserverList(anEnumerator); + rv = GetObserverList(aTopic, &anObserverList); + if (NS_FAILED(rv)) return rv; + + return anObserverList->RemoveObserver(anObserver); +} + +NS_IMETHODIMP nsObserverService::EnumerateObservers(const char* aTopic, nsISimpleEnumerator** anEnumerator) +{ + nsObserverList* anObserverList; + nsresult rv; + + if (anEnumerator == nsnull || aTopic == nsnull) + return NS_ERROR_NULL_POINTER; + + rv = GetObserverList(aTopic, &anObserverList); + if (NS_FAILED(rv)) return rv; + + return anObserverList->GetObserverList(anEnumerator); } // Enumerate observers of aTopic and call Observe on each. NS_IMETHODIMP nsObserverService::NotifyObservers(nsISupports *aSubject, const char *aTopic, - const PRUnichar *someData) -{ - NS_ENSURE_VALIDCALL - NS_ENSURE_ARG(aTopic); - - nsObserverList *observerList = mObserverTopicTable.GetEntry(aTopic); - if (observerList) - observerList->NotifyObservers(aSubject, aTopic, someData); + const PRUnichar *someData) { + nsresult rv = NS_OK; +#ifdef NOTIFY_GLOBAL_OBSERVERS + nsCOMPtr globalObservers; +#endif + nsCOMPtr observers; + nsCOMPtr observerRef; #ifdef NOTIFY_GLOBAL_OBSERVERS - observerList = mObserverTopicTable.GetEntry("*"); - if (observerList) - observerList->NotifyObservers(aSubject, aTopic, someData); + EnumerateObservers("*", getter_AddRefs(globalObservers)); +#endif + rv = EnumerateObservers(aTopic, getter_AddRefs(observers)); +#ifdef NOTIFY_GLOBAL_OBSERVERS + /* If there are no global observers and we failed to get normal observers + * then we return the error indicating failure to get normal observers. + */ + if (!globalObservers && NS_FAILED(rv)) + return rv; #endif + do + { + PRBool more = PR_FALSE; + /* If observers is non null then null it out unless it really + * has more elements (i.e. that call doesn't fail). + */ + if (observers && NS_FAILED(observers->HasMoreElements(&more)) || !more) + { +#ifdef NOTIFY_GLOBAL_OBSERVERS + if (observers = globalObservers) + globalObservers = nsnull; +#else + observers = nsnull; +#endif + } + else + { + observers->GetNext(getter_AddRefs(observerRef)); + nsCOMPtr observer = do_QueryInterface(observerRef); + if (observer) + observer->Observe(aSubject, aTopic, someData); + } + } while (observers); return NS_OK; } +//////////////////////////////////////////////////////////////////////////////// diff --git a/mozilla/xpcom/ds/nsObserverService.h b/mozilla/xpcom/ds/nsObserverService.h index 1f30b79c14a..0a08f2aeab5 100644 --- a/mozilla/xpcom/ds/nsObserverService.h +++ b/mozilla/xpcom/ds/nsObserverService.h @@ -39,37 +39,37 @@ #define nsObserverService_h___ #include "nsIObserverService.h" -#include "nsObserverList.h" -#include "nsTHashtable.h" #define NS_OBSERVERSERVICE_CONTRACTID "@mozilla.org/observer-service;1" #define NS_OBSERVERSERVICE_CLASSNAME "Observer Service" +class nsObserverList; +class nsObjectHashtable; + // {D07F5195-E3D1-11d2-8ACD-00105A1B8860} #define NS_OBSERVERSERVICE_CID \ { 0xd07f5195, 0xe3d1, 0x11d2, { 0x8a, 0xcd, 0x0, 0x10, 0x5a, 0x1b, 0x88, 0x60 } } class nsObserverService : public nsIObserverService { public: - NS_DECLARE_STATIC_IID_ACCESSOR(NS_OBSERVERSERVICE_CID) + NS_DEFINE_STATIC_CID_ACCESSOR( NS_OBSERVERSERVICE_CID ) nsObserverService(); - + NS_DECL_ISUPPORTS NS_DECL_NSIOBSERVERSERVICE - void Shutdown(); - static NS_METHOD Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr); private: ~nsObserverService(void); - PRBool mShuttingDown; - nsTHashtable mObserverTopicTable; + nsObjectHashtable* mObserverTopicTable; + + nsresult GetObserverList(const char* aTopic, nsObserverList** anObserverList); + + }; -NS_DEFINE_STATIC_IID_ACCESSOR(nsObserverService, NS_OBSERVERSERVICE_CID) - #endif /* nsObserverService_h___ */ diff --git a/mozilla/xpcom/glue/nsTArray.h b/mozilla/xpcom/glue/nsTArray.h index b4a73708f3f..faeae00c8cf 100644 --- a/mozilla/xpcom/glue/nsTArray.h +++ b/mozilla/xpcom/glue/nsTArray.h @@ -482,22 +482,18 @@ class nsTArray : public nsTArray_base { // and destroy" the first element that is equal to the given element. // @param item The item to search for. // @param comp The Comparator used to determine element equality. - // @return PR_TRUE if the element was found template - PRBool RemoveElement(const Item& item, const Comparator& comp) { + void RemoveElement(const Item& item, const Comparator& comp) { index_type i = IndexOf(item, 0, comp); - if (i == NoIndex) - return PR_FALSE; - - RemoveElementAt(i); - return PR_TRUE; + if (i != NoIndex) + RemoveElementAt(i); } // A variation on the RemoveElement method defined above that assumes // that 'operator==' is defined for elem_type. template - PRBool RemoveElement(const Item& item) { - return RemoveElement(item, nsDefaultComparator()); + void RemoveElement(const Item& item) { + RemoveElement(item, nsDefaultComparator()); } // diff --git a/mozilla/xpfe/components/windowds/nsWindowDataSource.cpp b/mozilla/xpfe/components/windowds/nsWindowDataSource.cpp index e1444a98673..1a0f66b809b 100644 --- a/mozilla/xpfe/components/windowds/nsWindowDataSource.cpp +++ b/mozilla/xpfe/components/windowds/nsWindowDataSource.cpp @@ -41,9 +41,8 @@ #include "nsIRDFContainerUtils.h" #include "nsIServiceManager.h" #include "nsReadableUtils.h" -#include "nsIObserverService.h" +#include "nsObserverService.h" #include "nsIWindowMediator.h" -#include "nsXPCOMCID.h" // just to do the reverse-lookup! sheesh. #include "nsIInterfaceRequestorUtils.h"