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;
}
