void *nsHashtable::Remove(nsHashKey *aKey) { if (!mHashtable.ops) return nsnull; if (mLock) PR_Lock(mLock); // shouldn't be adding an item during enumeration PR_ASSERT(!mEnumerating); // need to see if the entry is actually there, in order to get the // old value for the result HTEntry* entry = static_cast<HTEntry*> (PL_DHashTableOperate(&mHashtable, aKey, PL_DHASH_LOOKUP)); void *res; if (PL_DHASH_ENTRY_IS_FREE(entry)) { // value wasn't in the table anyway res = nsnull; } else { res = entry->value; PL_DHashTableRawRemove(&mHashtable, entry); } if (mLock) PR_Unlock(mLock); return res; }
nsresult nsStaticModuleLoader::GetModuleFor(const char *aLocation, nsIModule* *aResult) { nsresult rv; StaticModuleInfo *info = static_cast<StaticModuleInfo *> (PL_DHashTableOperate(&mInfoHash, aLocation, PL_DHASH_LOOKUP)); if (PL_DHASH_ENTRY_IS_FREE(info)) return NS_ERROR_FACTORY_NOT_REGISTERED; if (!info->module) { rv = info->info. getModule(nsComponentManagerImpl::gComponentManager, nsnull, getter_AddRefs(info->module)); LOG(("nSCL: GetModuleForFor(\"%s\"): %lx\n", aLocation, rv)); if (NS_FAILED(rv)) return rv; } NS_ADDREF(*aResult = info->module); return NS_OK; }
nsresult JavaToXPTCStubMap::Find(jint aJavaObjectHashCode, const nsIID& aIID, nsJavaXPTCStub** aResult) { NS_PRECONDITION(aResult != nsnull, "null ptr"); if (!aResult) return NS_ERROR_FAILURE; nsAutoLock lock(gJavaXPCOMLock); *aResult = nsnull; Entry* e = static_cast<Entry*> (PL_DHashTableOperate(mHashTable, NS_INT32_TO_PTR(aJavaObjectHashCode), PL_DHASH_LOOKUP)); if (PL_DHASH_ENTRY_IS_FREE(e)) return NS_OK; nsresult rv = e->xptcstub->QueryInterface(aIID, (void**) aResult); #ifdef DEBUG_JAVAXPCOM if (NS_SUCCEEDED(rv)) { char* iid_str = aIID.ToString(); LOG(("< JavaToXPTCStubMap (Java=%08x | XPCOM=%08x | IID=%s)\n", (PRUint32) aJavaObjectHashCode, (PRUint32) *aResult, iid_str)); PR_Free(iid_str); } #endif // NS_NOINTERFACE is not an error condition if (rv == NS_NOINTERFACE) rv = NS_OK; return rv; }
PrefHashEntry* pref_HashTableLookup(const void *key) { PrefHashEntry* result = static_cast<PrefHashEntry*>(PL_DHashTableOperate(&gHashTable, key, PL_DHASH_LOOKUP)); if (PL_DHASH_ENTRY_IS_FREE(result)) return nsnull; return result; }
nsresult NativeToJavaProxyMap::Remove(JNIEnv* env, nsISupports* aNativeObject, const nsIID& aIID) { // This is only called from finalizeProxy(), which already holds the lock. // nsAutoLock lock(gJavaXPCOMLock); Entry* e = static_cast<Entry*>(PL_DHashTableOperate(mHashTable, aNativeObject, PL_DHASH_LOOKUP)); if (PL_DHASH_ENTRY_IS_FREE(e)) { NS_WARNING("XPCOM object not found in hash table"); return NS_ERROR_FAILURE; } ProxyList* item = e->list; ProxyList* last = e->list; while (item != nsnull) { if (item->iid.Equals(aIID)) { #ifdef DEBUG_JAVAXPCOM char* iid_str = aIID.ToString(); LOG(("- NativeToJavaProxyMap (Java=%08x | XPCOM=%08x | IID=%s)\n", (PRUint32) env->CallStaticIntMethod(systemClass, hashCodeMID, item->javaObject), (PRUint32) aNativeObject, iid_str)); NS_Free(iid_str); #endif env->CallVoidMethod(item->javaObject, clearReferentMID); env->DeleteGlobalRef(item->javaObject); if (item == e->list) { e->list = item->next; if (e->list == nsnull) PL_DHashTableOperate(mHashTable, aNativeObject, PL_DHASH_REMOVE); } else { last->next = item->next; } delete item; return NS_OK; } last = item; item = item->next; } NS_WARNING("Java proxy matching given IID not found"); return NS_ERROR_FAILURE; }
NS_IMETHODIMP nsPersistentProperties::GetStringProperty(const nsACString& aKey, nsAString& aValue) { const nsAFlatCString& flatKey = PromiseFlatCString(aKey); PropertyTableEntry *entry = static_cast<PropertyTableEntry*> (PL_DHashTableOperate(&mTable, flatKey.get(), PL_DHASH_LOOKUP)); if (PL_DHASH_ENTRY_IS_FREE(entry)) return NS_ERROR_FAILURE; aValue = entry->mValue; return NS_OK; }
/** * FindActiveEntry : to find active colliding entry so we can doom it */ nsDiskCacheBinding * nsDiskCacheBindery::FindActiveBinding(PRUint32 hashNumber) { NS_ASSERTION(initialized, "nsDiskCacheBindery not initialized"); // find hash entry for key HashTableEntry * hashEntry; hashEntry = (HashTableEntry *) PL_DHashTableOperate(&table, (void*) hashNumber, PL_DHASH_LOOKUP); if (PL_DHASH_ENTRY_IS_FREE(hashEntry)) return nsnull; // walk list looking for active entry NS_ASSERTION(hashEntry->mBinding, "hash entry left with no binding"); nsDiskCacheBinding * binding = hashEntry->mBinding; while (binding->mCacheEntry->IsDoomed()) { binding = (nsDiskCacheBinding *)PR_NEXT_LINK(binding); if (binding == hashEntry->mBinding) return nsnull; } return binding; }
PRInt32 nsStaticCaseInsensitiveNameTable::Lookup(const nsAString& aName) { NS_ASSERTION(mNameArray, "not inited"); NS_ASSERTION(mNameTable.ops, "not inited"); const nsAFlatString& str = PromiseFlatString(aName); NameTableKey key(&str); NameTableEntry *entry = static_cast<NameTableEntry*> (PL_DHashTableOperate(&mNameTable, &key, PL_DHASH_LOOKUP)); if (PL_DHASH_ENTRY_IS_FREE(entry)) return nsStaticCaseInsensitiveNameTable::NOT_FOUND; return entry->mIndex; }
nsresult NativeToJavaProxyMap::Find(JNIEnv* env, nsISupports* aNativeObject, const nsIID& aIID, jobject* aResult) { NS_PRECONDITION(aResult != nsnull, "null ptr"); if (!aResult) return NS_ERROR_FAILURE; nsAutoLock lock(gJavaXPCOMLock); *aResult = nsnull; Entry* e = static_cast<Entry*>(PL_DHashTableOperate(mHashTable, aNativeObject, PL_DHASH_LOOKUP)); if (PL_DHASH_ENTRY_IS_FREE(e)) return NS_OK; ProxyList* item = e->list; while (item != nsnull && *aResult == nsnull) { if (item->iid.Equals(aIID)) { jobject referentObj = env->CallObjectMethod(item->javaObject, getReferentMID); if (!env->IsSameObject(referentObj, NULL)) { *aResult = referentObj; #ifdef DEBUG_JAVAXPCOM char* iid_str = aIID.ToString(); LOG(("< NativeToJavaProxyMap (Java=%08x | XPCOM=%08x | IID=%s)\n", (PRUint32) env->CallStaticIntMethod(systemClass, hashCodeMID, *aResult), (PRUint32) aNativeObject, iid_str)); NS_Free(iid_str); #endif } } item = item->next; } return NS_OK; }
NS_IMETHODIMP nsLoadGroup::RemoveRequest(nsIRequest *request, nsISupports* ctxt, nsresult aStatus) { NS_ENSURE_ARG_POINTER(request); nsresult rv; #if defined(PR_LOGGING) { nsCAutoString nameStr; request->GetName(nameStr); LOG(("LOADGROUP [%x]: Removing request %x %s status %x (count=%d).\n", this, request, nameStr.get(), aStatus, mRequests.entryCount-1)); } #endif // Make sure we have a owning reference to the request we're about // to remove. nsCOMPtr<nsIRequest> kungFuDeathGrip(request); // // Remove the request from the group. If this fails, it means that // the request was *not* in the group so do not update the foreground // count or it will get messed up... // RequestMapEntry *entry = static_cast<RequestMapEntry *> (PL_DHashTableOperate(&mRequests, request, PL_DHASH_LOOKUP)); if (PL_DHASH_ENTRY_IS_FREE(entry)) { LOG(("LOADGROUP [%x]: Unable to remove request %x. Not in group!\n", this, request)); return NS_ERROR_FAILURE; } PL_DHashTableRawRemove(&mRequests, entry); // Undo any group priority delta... if (mPriority != 0) RescheduleRequest(request, -mPriority); nsLoadFlags flags; rv = request->GetLoadFlags(&flags); if (NS_FAILED(rv)) return rv; if (!(flags & nsIRequest::LOAD_BACKGROUND)) { NS_ASSERTION(mForegroundCount > 0, "ForegroundCount messed up"); mForegroundCount -= 1; // Fire the OnStopRequest out to the observer... nsCOMPtr<nsIRequestObserver> observer = do_QueryReferent(mObserver); if (observer) { LOG(("LOADGROUP [%x]: Firing OnStopRequest for request %x." "(foreground count=%d).\n", this, request, mForegroundCount)); rv = observer->OnStopRequest(request, ctxt, aStatus); #if defined(PR_LOGGING) if (NS_FAILED(rv)) { LOG(("LOADGROUP [%x]: OnStopRequest for request %x FAILED.\n", this, request)); } #endif } // If that was the last request -> remove ourselves from loadgroup if (mForegroundCount == 0 && mLoadGroup) { mLoadGroup->RemoveRequest(this, nsnull, aStatus); } } return rv; }
NS_IMETHODIMP nsLoadGroup::AddRequest(nsIRequest *request, nsISupports* ctxt) { nsresult rv; #if defined(PR_LOGGING) { nsCAutoString nameStr; request->GetName(nameStr); LOG(("LOADGROUP [%x]: Adding request %x %s (count=%d).\n", this, request, nameStr.get(), mRequests.entryCount)); } #endif /* PR_LOGGING */ #ifdef DEBUG { RequestMapEntry *entry = static_cast<RequestMapEntry *> (PL_DHashTableOperate(&mRequests, request, PL_DHASH_LOOKUP)); NS_ASSERTION(PL_DHASH_ENTRY_IS_FREE(entry), "Entry added to loadgroup twice, don't do that"); } #endif // // Do not add the channel, if the loadgroup is being canceled... // if (mIsCanceling) { #if defined(PR_LOGGING) LOG(("LOADGROUP [%x]: AddChannel() ABORTED because LoadGroup is" " being canceled!!\n", this)); #endif /* PR_LOGGING */ return NS_BINDING_ABORTED; } nsLoadFlags flags; // if the request is the default load request or if the default // load request is null, then the load group should inherit its // load flags from the request. if (mDefaultLoadRequest == request || !mDefaultLoadRequest) rv = request->GetLoadFlags(&flags); else rv = MergeLoadFlags(request, flags); if (NS_FAILED(rv)) return rv; // // Add the request to the list of active requests... // RequestMapEntry *entry = static_cast<RequestMapEntry *> (PL_DHashTableOperate(&mRequests, request, PL_DHASH_ADD)); if (!entry) { return NS_ERROR_OUT_OF_MEMORY; } if (mPriority != 0) RescheduleRequest(request, mPriority); if (!(flags & nsIRequest::LOAD_BACKGROUND)) { // Update the count of foreground URIs.. mForegroundCount += 1; // // Fire the OnStartRequest notification out to the observer... // // If the notification fails then DO NOT add the request to // the load group. // nsCOMPtr<nsIRequestObserver> observer = do_QueryReferent(mObserver); if (observer) { LOG(("LOADGROUP [%x]: Firing OnStartRequest for request %x." "(foreground count=%d).\n", this, request, mForegroundCount)); rv = observer->OnStartRequest(request, ctxt); if (NS_FAILED(rv)) { LOG(("LOADGROUP [%x]: OnStartRequest for request %x FAILED.\n", this, request)); // // The URI load has been canceled by the observer. Clean up // the damage... // PL_DHashTableOperate(&mRequests, request, PL_DHASH_REMOVE); rv = NS_OK; mForegroundCount -= 1; } } // Ensure that we're part of our loadgroup while pending if (mForegroundCount == 1 && mLoadGroup) { mLoadGroup->AddRequest(this, nsnull); } } return rv; }
NS_IMETHODIMP nsLoadGroup::Cancel(nsresult status) { NS_ASSERTION(NS_FAILED(status), "shouldn't cancel with a success code"); nsresult rv; PRUint32 count = mRequests.entryCount; nsAutoTArray<nsIRequest*, 8> requests; PL_DHashTableEnumerate(&mRequests, AppendRequestsToArray, static_cast<nsTArray<nsIRequest*> *>(&requests)); if (requests.Length() != count) { for (PRUint32 i = 0, len = requests.Length(); i < len; ++i) { NS_RELEASE(requests[i]); } return NS_ERROR_OUT_OF_MEMORY; } // set the load group status to our cancel status while we cancel // all our requests...once the cancel is done, we'll reset it... // mStatus = status; // Set the flag indicating that the loadgroup is being canceled... This // prevents any new channels from being added during the operation. // mIsCanceling = PR_TRUE; nsresult firstError = NS_OK; while (count > 0) { nsIRequest* request = requests.ElementAt(--count); NS_ASSERTION(request, "NULL request found in list."); RequestMapEntry *entry = static_cast<RequestMapEntry *> (PL_DHashTableOperate(&mRequests, request, PL_DHASH_LOOKUP)); if (PL_DHASH_ENTRY_IS_FREE(entry)) { // |request| was removed already NS_RELEASE(request); continue; } #if defined(PR_LOGGING) nsCAutoString nameStr; request->GetName(nameStr); LOG(("LOADGROUP [%x]: Canceling request %x %s.\n", this, request, nameStr.get())); #endif // // Remove the request from the load group... This may cause // the OnStopRequest notification to fire... // // XXX: What should the context be? // (void)RemoveRequest(request, nsnull, status); // Cancel the request... rv = request->Cancel(status); // Remember the first failure and return it... if (NS_FAILED(rv) && NS_SUCCEEDED(firstError)) firstError = rv; NS_RELEASE(request); } #if defined(DEBUG) NS_ASSERTION(mRequests.entryCount == 0, "Request list is not empty."); NS_ASSERTION(mForegroundCount == 0, "Foreground URLs are active."); #endif mStatus = NS_OK; mIsCanceling = PR_FALSE; return firstError; }