From 17f1f876c4915c13fbbb13a089ad62a006afb64c Mon Sep 17 00:00:00 2001 From: "aaronl%netscape.com" Date: Thu, 22 May 2003 09:45:03 +0000 Subject: [PATCH] Backing out bug 202080 until I can figure out bustage --- accessible/src/base/nsAccessNode.cpp | 83 ++++++++++++++++--- accessible/src/base/nsAccessNode.h | 58 +++++++++---- .../src/base/nsAccessibilityService.cpp | 5 +- accessible/src/base/nsDocAccessible.cpp | 27 +++++- accessible/src/base/nsDocAccessible.h | 5 ++ 5 files changed, 144 insertions(+), 34 deletions(-) diff --git a/accessible/src/base/nsAccessNode.cpp b/accessible/src/base/nsAccessNode.cpp index edf59945b9ff..cce7a3e25660 100755 --- a/accessible/src/base/nsAccessNode.cpp +++ b/accessible/src/base/nsAccessNode.cpp @@ -61,7 +61,12 @@ nsIDOMNode *nsAccessNode::gLastFocusedNode = 0; PRBool nsAccessNode::gIsAccessibilityActive = PR_FALSE; PRBool nsAccessNode::gIsCacheDisabled = PR_FALSE; + +#ifdef OLD_HASH +nsSupportsHashtable *nsAccessNode::gGlobalDocAccessibleCache = nsnull; +#else nsInterfaceHashtable *nsAccessNode::gGlobalDocAccessibleCache = nsnull; +#endif /* * Class nsAccessNode @@ -181,8 +186,12 @@ void nsAccessNode::InitXPAccessibility() } nsAccessibilityAtoms::AddRefAtoms(); +#ifdef OLD_HASH + gGlobalDocAccessibleCache = new nsSupportsHashtable(4); +#else gGlobalDocAccessibleCache = new nsInterfaceHashtable; gGlobalDocAccessibleCache->Init(4); // Initialize for 4 entries +#endif nsCOMPtr prefService(do_GetService(kPrefCID)); if (prefService) { @@ -205,7 +214,7 @@ void nsAccessNode::ShutdownXPAccessibility() NS_IF_RELEASE(gKeyStringBundle); NS_IF_RELEASE(gLastFocusedNode); - ClearCache(*gGlobalDocAccessibleCache); + ClearCache(gGlobalDocAccessibleCache); delete gGlobalDocAccessibleCache; gGlobalDocAccessibleCache = nsnull; @@ -261,6 +270,55 @@ nsIFrame* nsAccessNode::GetFrame() /***************** Hashtable of nsIAccessNode's *****************/ +#ifdef OLD_HASH +void nsAccessNode::GetDocAccessibleFor(nsIWeakReference *aPresShell, + nsIAccessibleDocument **aDocAccessible) +{ + *aDocAccessible = nsnull; + NS_ASSERTION(gGlobalDocAccessibleCache, "Global doc cache does not exist"); + + nsVoidKey key(NS_STATIC_CAST(void*, aPresShell)); + nsCOMPtr accessNode = NS_STATIC_CAST(nsIAccessNode*, gGlobalDocAccessibleCache->Get(&key)); + nsCOMPtr accDoc(do_QueryInterface(accessNode)); + *aDocAccessible = accDoc; // already addrefed +} + +void nsAccessNode::PutCacheEntry(nsSupportsHashtable *aCache, void* aUniqueID, + nsIAccessNode *aAccessNode) +{ + nsVoidKey key(aUniqueID); +#ifdef DEBUG + if (aCache->Exists(&key)) { + NS_ASSERTION(PR_FALSE, "This cache entry shouldn't exist already"); + nsCOMPtr oldAccessNode; + GetCacheEntry(aCache, aUniqueID, getter_AddRefs(oldAccessNode)); + } +#endif + aCache->Put(&key, aAccessNode); +} + +void nsAccessNode::GetCacheEntry(nsSupportsHashtable *aCache, void* aUniqueID, + nsIAccessNode **aAccessNode) +{ + nsVoidKey key(aUniqueID); + *aAccessNode = NS_STATIC_CAST(nsIAccessNode*, aCache->Get(&key)); // AddRefs for us +} + +PRIntn PR_CALLBACK nsAccessNode::ClearCacheEntry(nsHashKey *aKey, void *aAccessNode, + void* aClosure) +{ + nsIAccessNode* accessNode = NS_STATIC_CAST(nsIAccessNode*, aAccessNode); + accessNode->Shutdown(); + + return kHashEnumerateRemove; +} + +void nsAccessNode::ClearCache(nsSupportsHashtable *aCache) +{ + aCache->Enumerate(ClearCacheEntry); +} + +#else void nsAccessNode::GetDocAccessibleFor(nsIWeakReference *aPresShell, nsIAccessibleDocument **aDocAccessible) { @@ -274,35 +332,34 @@ void nsAccessNode::GetDocAccessibleFor(nsIWeakReference *aPresShell, } } -void nsAccessNode::PutCacheEntry(nsInterfaceHashtable &aCache, +void nsAccessNode::PutCacheEntry(nsInterfaceHashtable *aCache, void* aUniqueID, nsIAccessNode *aAccessNode) { -#ifdef DEBUG - nsCOMPtr oldAccessNode; - GetCacheEntry(aCache, aUniqueID, getter_AddRefs(oldAccessNode)); - NS_ASSERTION(!oldAccessNode, "This cache entry shouldn't exist already"); -#endif - aCache.Put(aUniqueID, aAccessNode); + aCache->Put(aUniqueID, aAccessNode); } -void nsAccessNode::GetCacheEntry(nsInterfaceHashtable &aCache, +void nsAccessNode::GetCacheEntry(nsInterfaceHashtable *aCache, void* aUniqueID, nsIAccessNode **aAccessNode) { - aCache.Get(aUniqueID, aAccessNode); // AddRefs for us + aCache->Get(aUniqueID, aAccessNode); // AddRefs for us } -PLDHashOperator nsAccessNode::ClearCacheEntry(const void* aKey, nsCOMPtr& aAccessNode, void* aUserArg) +PLDHashOperator ClearCacheEntry(void *const& aKey, nsCOMPtr aAccessNode, void* aUserArg) { aAccessNode->Shutdown(); return PL_DHASH_REMOVE; } -void nsAccessNode::ClearCache(nsInterfaceHashtable &aCache) +void nsAccessNode::ClearCache(nsInterfaceHashtable *aCache) { - aCache.Enumerate(ClearCacheEntry, nsnull); + //aCache->EnumerateEntries(ClearCacheEntry, nsnull); + aCache->EnumerateRead(ClearCacheEntry, nsnull); + aCache->Clear(); } +#endif + diff --git a/accessible/src/base/nsAccessNode.h b/accessible/src/base/nsAccessNode.h index 252a57364f06..beb336e74c66 100755 --- a/accessible/src/base/nsAccessNode.h +++ b/accessible/src/base/nsAccessNode.h @@ -49,7 +49,16 @@ #include "nsIStringBundle.h" #include "nsWeakReference.h" +#define OLD_HASH 1 + +#ifdef OLD_HASH +class nsSupportsHashtable; +class nsHashKey; +#include "nsHashtable.h" +#else #include "nsInterfaceHashtable.h" +#include "pldhash.h" +#endif class nsIPresShell; class nsIPresContext; @@ -63,31 +72,34 @@ enum { eSiblingsUninitialized = -1, eSiblingsWalkNormalDOM = -2 }; #define ACCESSIBLE_BUNDLE_URL "chrome://global-platform/locale/accessible.properties" #define PLATFORM_KEYS_BUNDLE_URL "chrome://global-platform/locale/platformKeys.properties" +#ifndef OLD_HASH /* hashkey wrapper using void* KeyType * * @see nsTHashtable::EntryType for specification */ -class nsVoidHashKey : public PLDHashEntryHdr +class NS_COM nsVoidHashKey : public PLDHashEntryHdr { -public: - typedef const void* KeyType; - typedef const void* KeyTypePointer; +public: typedef void* voidPointer; + typedef const voidPointer& KeyType; + typedef const voidPointer* KeyTypePointer; - nsVoidHashKey(KeyTypePointer aKey) : mValue(aKey) { } + const voidPointer mValue; + +public: + nsVoidHashKey(KeyTypePointer aKey) : mValue(*aKey) { } nsVoidHashKey(const nsVoidHashKey& toCopy) : mValue(toCopy.mValue) { } ~nsVoidHashKey() { } KeyType GetKey() const { return mValue; } - KeyTypePointer GetKeyPointer() const { return mValue; } - PRBool KeyEquals(KeyTypePointer aKey) const { return aKey == mValue; } + KeyTypePointer GetKeyPointer() const { return &mValue; } + PRBool KeyEquals(KeyTypePointer aKey) const { return *aKey == mValue; } - static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; } - static PLDHashNumber HashKey(KeyTypePointer aKey) { return NS_PTR_TO_INT32(aKey) >> 2; } - enum { ALLOW_MEMMOVE = PR_TRUE }; + static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; } + static PLDHashNumber HashKey(KeyTypePointer aKey) { return NS_PTR_TO_INT32(*aKey) >> 2; } + static PRBool AllowMemMove() { return PR_TRUE; } -private: - const void* mValue; }; +#endif class nsAccessNode: public nsIAccessNode { @@ -104,13 +116,23 @@ class nsAccessNode: public nsIAccessNode static void ShutdownXPAccessibility(); // Static methods for handling per-document cache - static void PutCacheEntry(nsInterfaceHashtable& aCache, +#ifdef OLD_HASH + static void PutCacheEntry(nsSupportsHashtable *aCache, void* aUniqueID, nsIAccessNode *aAccessNode); - static void GetCacheEntry(nsInterfaceHashtable& aCache, void* aUniqueID, + static void GetCacheEntry(nsSupportsHashtable *aCache, void* aUniqueID, nsIAccessNode **aAccessNode); - static void ClearCache(nsInterfaceHashtable& aCache); + static void ClearCache(nsSupportsHashtable *aCache); + static PRIntn PR_CALLBACK ClearCacheEntry(nsHashKey *aKey, void *aData, + void* aClosure); +#else + static void PutCacheEntry(nsInterfaceHashtable *aCache, + void* aUniqueID, nsIAccessNode *aAccessNode); + static void GetCacheEntry(nsInterfaceHashtable *aCache, void* aUniqueID, + nsIAccessNode **aAccessNode); + static void ClearCache(nsInterfaceHashtable *aCache); - static PLDHashOperator PR_CALLBACK ClearCacheEntry(const void* aKey, nsCOMPtr& aAccessNode, void* aUserArg); + static PLDHashOperator PR_CALLBACK ClearCacheEntry(void *const& aKey, nsCOMPtr aAccessNode, void* aUserArg); +#endif // Static cache methods for global document cache static void GetDocAccessibleFor(nsIWeakReference *aPresShell, @@ -140,7 +162,11 @@ class nsAccessNode: public nsIAccessNode static PRBool gIsAccessibilityActive; static PRBool gIsCacheDisabled; +#ifdef OLD_HASH + static nsSupportsHashtable *gGlobalDocAccessibleCache; +#else static nsInterfaceHashtable *gGlobalDocAccessibleCache; +#endif }; #endif diff --git a/accessible/src/base/nsAccessibilityService.cpp b/accessible/src/base/nsAccessibilityService.cpp index c1d2ec21c730..efdf3389d1a3 100644 --- a/accessible/src/base/nsAccessibilityService.cpp +++ b/accessible/src/base/nsAccessibilityService.cpp @@ -1442,6 +1442,9 @@ NS_IMETHODIMP nsAccessibilityService::GetCachedAccessNode(nsIDOMNode *aNode, nsAccessNode::GetDocAccessibleFor(aWeakShell, getter_AddRefs(accessibleDoc)); if (!accessibleDoc) { +#ifdef DEBUG_aaronl + printf("\nWARNING: No accessible document for weak shell %x\n", aWeakShell); +#endif *aAccessNode = nsnull; return NS_ERROR_FAILURE; } @@ -1520,7 +1523,7 @@ nsresult nsAccessibilityService::GetAccessible(nsIDOMNode *aNode, // Please leave this in for now, it's a convenient debugging method nsAutoString name; aNode->GetLocalName(name); - if (name.EqualsIgnoreCase("object")) + if (name.EqualsIgnoreCase("browser")) printf("## aaronl debugging tag name\n"); nsAutoString attrib; diff --git a/accessible/src/base/nsDocAccessible.cpp b/accessible/src/base/nsDocAccessible.cpp index 5add325ece8e..111a7540d64c 100644 --- a/accessible/src/base/nsDocAccessible.cpp +++ b/accessible/src/base/nsDocAccessible.cpp @@ -37,6 +37,7 @@ * ***** END LICENSE BLOCK ***** */ #include "nsDocAccessible.h" +#include "nsHashtable.h" #include "nsIAccessibilityService.h" #include "nsICommandManager.h" #include "nsIDocShell.h" @@ -106,11 +107,15 @@ nsDocAccessible::nsDocAccessible(nsIDOMNode *aDOMNode, nsIWeakReference* aShell) } NS_ASSERTION(gGlobalDocAccessibleCache, "No global doc accessible cache"); - PutCacheEntry(*gGlobalDocAccessibleCache, mWeakShell, this); + PutCacheEntry(gGlobalDocAccessibleCache, mWeakShell, this); // XXX aaronl should we use an algorithm for the initial cache size? +#ifdef OLD_HASH + mAccessNodeCache = new nsSupportsHashtable(kDefaultCacheSize); +#else mAccessNodeCache = new nsInterfaceHashtable; mAccessNodeCache->Init(kDefaultCacheSize); +#endif } //----------------------------------------------------- @@ -293,14 +298,14 @@ NS_IMETHODIMP nsDocAccessible::GetIsEditable(PRBool *aIsEditable) NS_IMETHODIMP nsDocAccessible::GetCachedAccessNode(void *aUniqueID, nsIAccessNode **aAccessNode) { NS_ASSERTION(mAccessNodeCache, "No accessibility cache for document"); - GetCacheEntry(*mAccessNodeCache, aUniqueID, aAccessNode); // Addrefs for us + GetCacheEntry(mAccessNodeCache, aUniqueID, aAccessNode); // Addrefs for us return NS_OK; } NS_IMETHODIMP nsDocAccessible::CacheAccessNode(void *aUniqueID, nsIAccessNode *aAccessNode) { NS_ASSERTION(mAccessNodeCache, "No accessibility cache for document"); - PutCacheEntry(*mAccessNodeCache, aUniqueID, aAccessNode); + PutCacheEntry(mAccessNodeCache, aUniqueID, aAccessNode); return NS_OK; } @@ -342,7 +347,12 @@ NS_IMETHODIMP nsDocAccessible::Destroy() { NS_ASSERTION(gGlobalDocAccessibleCache, "No global doc accessible cache"); if (gGlobalDocAccessibleCache) { +#ifdef OLD_HASH + nsVoidKey key(NS_STATIC_CAST(void*, mWeakShell)); + gGlobalDocAccessibleCache->Remove(&key); +#else gGlobalDocAccessibleCache->Remove(NS_STATIC_CAST(void*, mWeakShell)); +#endif } return Shutdown(); } @@ -370,9 +380,13 @@ NS_IMETHODIMP nsDocAccessible::Shutdown() mWebProgress = nsnull; if (mAccessNodeCache) { +#ifdef OLD_HASH + nsSupportsHashtable *hashToClear = mAccessNodeCache; // Avoid reentrency +#else nsInterfaceHashtable *hashToClear = mAccessNodeCache; // Avoid reentrency +#endif mAccessNodeCache = nsnull; - ClearCache(*hashToClear); + ClearCache(hashToClear); delete hashToClear; } @@ -869,7 +883,12 @@ NS_IMETHODIMP nsDocAccessible::InvalidateCacheSubtree(nsIDOMNode *aStartNode) accessNode->GetUniqueID(&uniqueID); accessNode->Shutdown(); // Remove from hash table as well +#ifdef OLD_HASH + nsVoidKey key(uniqueID); + mAccessNodeCache->Remove(&key); +#else mAccessNodeCache->Remove(uniqueID); +#endif } } diff --git a/accessible/src/base/nsDocAccessible.h b/accessible/src/base/nsDocAccessible.h index 010ce7f24c4a..db45d1a29788 100644 --- a/accessible/src/base/nsDocAccessible.h +++ b/accessible/src/base/nsDocAccessible.h @@ -40,6 +40,7 @@ #define _nsDocAccessible_H_ #include "nsAccessibleWrap.h" +#include "nsHashtable.h" #include "nsIAccessibleDocument.h" #include "nsIAccessibleEventReceiver.h" #include "nsIDocument.h" @@ -117,7 +118,11 @@ class nsDocAccessible : public nsAccessibleWrap, nsIAccessibleDocument **aAccessibleDoc); void CheckForEditor(); +#ifdef OLD_HASH + nsSupportsHashtable *mAccessNodeCache; +#else nsInterfaceHashtable *mAccessNodeCache; +#endif void *mWnd; nsCOMPtr mDocument; nsCOMPtr mScrollWatchTimer;