forked from mirrors/gecko-dev
87438519f0
Before P1, GetCurrentThreadSerialEventTarget would have always returned the same data as NS_GetCurrentThread, making the comment incorrect Now it will properly return the running TaskQueue if any. This change of name more clearly exposes what they are doing, as we aren't always dealing with threads directly; but a nsISerialEventTarget Differential Revision: https://phabricator.services.mozilla.com/D80354
415 lines
12 KiB
C++
415 lines
12 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "nsCache.h"
|
|
#include "nspr.h"
|
|
#include "nsCacheEntry.h"
|
|
#include "nsCacheEntryDescriptor.h"
|
|
#include "nsCacheMetaData.h"
|
|
#include "nsCacheRequest.h"
|
|
#include "nsThreadUtils.h"
|
|
#include "nsError.h"
|
|
#include "nsCacheService.h"
|
|
#include "nsCacheDevice.h"
|
|
#include "nsHashKeys.h"
|
|
|
|
using namespace mozilla;
|
|
|
|
nsCacheEntry::nsCacheEntry(const nsACString& key, bool streamBased,
|
|
nsCacheStoragePolicy storagePolicy)
|
|
: mKey(key),
|
|
mFetchCount(0),
|
|
mLastFetched(0),
|
|
mLastModified(0),
|
|
mLastValidated(0),
|
|
mExpirationTime(nsICache::NO_EXPIRATION_TIME),
|
|
mFlags(0),
|
|
mPredictedDataSize(-1),
|
|
mDataSize(0),
|
|
mCacheDevice(nullptr),
|
|
mCustomDevice(nullptr),
|
|
mData(nullptr),
|
|
mRequestQ{},
|
|
mDescriptorQ{} {
|
|
MOZ_COUNT_CTOR(nsCacheEntry);
|
|
PR_INIT_CLIST(this);
|
|
PR_INIT_CLIST(&mRequestQ);
|
|
PR_INIT_CLIST(&mDescriptorQ);
|
|
|
|
if (streamBased) MarkStreamBased();
|
|
SetStoragePolicy(storagePolicy);
|
|
|
|
MarkPublic();
|
|
}
|
|
|
|
nsCacheEntry::~nsCacheEntry() {
|
|
MOZ_COUNT_DTOR(nsCacheEntry);
|
|
|
|
if (mData) nsCacheService::ReleaseObject_Locked(mData, mEventTarget);
|
|
}
|
|
|
|
nsresult nsCacheEntry::Create(const char* key, bool streamBased,
|
|
nsCacheStoragePolicy storagePolicy,
|
|
nsCacheDevice* device, nsCacheEntry** result) {
|
|
nsCacheEntry* entry =
|
|
new nsCacheEntry(nsCString(key), streamBased, storagePolicy);
|
|
entry->SetCacheDevice(device);
|
|
*result = entry;
|
|
return NS_OK;
|
|
}
|
|
|
|
void nsCacheEntry::Fetched() {
|
|
mLastFetched = SecondsFromPRTime(PR_Now());
|
|
++mFetchCount;
|
|
MarkEntryDirty();
|
|
}
|
|
|
|
const char* nsCacheEntry::GetDeviceID() {
|
|
if (mCacheDevice) return mCacheDevice->GetDeviceID();
|
|
return nullptr;
|
|
}
|
|
|
|
void nsCacheEntry::TouchData() {
|
|
mLastModified = SecondsFromPRTime(PR_Now());
|
|
MarkDataDirty();
|
|
}
|
|
|
|
void nsCacheEntry::SetData(nsISupports* data) {
|
|
if (mData) {
|
|
nsCacheService::ReleaseObject_Locked(mData, mEventTarget);
|
|
mData = nullptr;
|
|
}
|
|
|
|
if (data) {
|
|
NS_ADDREF(mData = data);
|
|
mEventTarget = GetCurrentEventTarget();
|
|
}
|
|
}
|
|
|
|
void nsCacheEntry::TouchMetaData() {
|
|
mLastModified = SecondsFromPRTime(PR_Now());
|
|
MarkMetaDataDirty();
|
|
}
|
|
|
|
/**
|
|
* cache entry states
|
|
* 0 descriptors (new entry)
|
|
* 0 descriptors (existing, bound entry)
|
|
* n descriptors (existing, bound entry) valid
|
|
* n descriptors (existing, bound entry) not valid (wait until valid or
|
|
* doomed)
|
|
*/
|
|
|
|
nsresult nsCacheEntry::RequestAccess(nsCacheRequest* request,
|
|
nsCacheAccessMode* accessGranted) {
|
|
nsresult rv = NS_OK;
|
|
|
|
if (IsDoomed()) return NS_ERROR_CACHE_ENTRY_DOOMED;
|
|
|
|
if (!IsInitialized()) {
|
|
// brand new, unbound entry
|
|
if (request->IsStreamBased()) MarkStreamBased();
|
|
MarkInitialized();
|
|
|
|
*accessGranted = request->AccessRequested() & nsICache::ACCESS_WRITE;
|
|
NS_ASSERTION(*accessGranted, "new cache entry for READ-ONLY request");
|
|
PR_APPEND_LINK(request, &mRequestQ);
|
|
return rv;
|
|
}
|
|
|
|
if (IsStreamData() != request->IsStreamBased()) {
|
|
*accessGranted = nsICache::ACCESS_NONE;
|
|
return request->IsStreamBased() ? NS_ERROR_CACHE_DATA_IS_NOT_STREAM
|
|
: NS_ERROR_CACHE_DATA_IS_STREAM;
|
|
}
|
|
|
|
if (PR_CLIST_IS_EMPTY(&mDescriptorQ)) {
|
|
// 1st descriptor for existing bound entry
|
|
*accessGranted = request->AccessRequested();
|
|
if (*accessGranted & nsICache::ACCESS_WRITE) {
|
|
MarkInvalid();
|
|
} else {
|
|
MarkValid();
|
|
}
|
|
} else {
|
|
// nth request for existing, bound entry
|
|
*accessGranted = request->AccessRequested() & ~nsICache::ACCESS_WRITE;
|
|
if (!IsValid()) rv = NS_ERROR_CACHE_WAIT_FOR_VALIDATION;
|
|
}
|
|
PR_APPEND_LINK(request, &mRequestQ);
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult nsCacheEntry::CreateDescriptor(nsCacheRequest* request,
|
|
nsCacheAccessMode accessGranted,
|
|
nsICacheEntryDescriptor** result) {
|
|
NS_ENSURE_ARG_POINTER(request && result);
|
|
|
|
nsCacheEntryDescriptor* descriptor =
|
|
new nsCacheEntryDescriptor(this, accessGranted);
|
|
|
|
// XXX check request is on q
|
|
PR_REMOVE_AND_INIT_LINK(request); // remove request regardless of success
|
|
|
|
if (descriptor == nullptr) return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
PR_APPEND_LINK(descriptor, &mDescriptorQ);
|
|
|
|
CACHE_LOG_DEBUG((" descriptor %p created for request %p on entry %p\n",
|
|
descriptor, request, this));
|
|
|
|
*result = do_AddRef(descriptor).take();
|
|
return NS_OK;
|
|
}
|
|
|
|
bool nsCacheEntry::RemoveRequest(nsCacheRequest* request) {
|
|
// XXX if debug: verify this request belongs to this entry
|
|
PR_REMOVE_AND_INIT_LINK(request);
|
|
|
|
// return true if this entry should stay active
|
|
return !((PR_CLIST_IS_EMPTY(&mRequestQ)) &&
|
|
(PR_CLIST_IS_EMPTY(&mDescriptorQ)));
|
|
}
|
|
|
|
bool nsCacheEntry::RemoveDescriptor(nsCacheEntryDescriptor* descriptor,
|
|
bool* doomEntry) {
|
|
NS_ASSERTION(descriptor->CacheEntry() == this, "### Wrong cache entry!!");
|
|
|
|
*doomEntry = descriptor->ClearCacheEntry();
|
|
|
|
PR_REMOVE_AND_INIT_LINK(descriptor);
|
|
|
|
if (!PR_CLIST_IS_EMPTY(&mDescriptorQ))
|
|
return true; // stay active if we still have open descriptors
|
|
|
|
if (PR_CLIST_IS_EMPTY(&mRequestQ))
|
|
return false; // no descriptors or requests, we can deactivate
|
|
|
|
return true; // find next best request to give a descriptor to
|
|
}
|
|
|
|
void nsCacheEntry::DetachDescriptors() {
|
|
nsCacheEntryDescriptor* descriptor =
|
|
(nsCacheEntryDescriptor*)PR_LIST_HEAD(&mDescriptorQ);
|
|
|
|
while (descriptor != &mDescriptorQ) {
|
|
nsCacheEntryDescriptor* nextDescriptor =
|
|
(nsCacheEntryDescriptor*)PR_NEXT_LINK(descriptor);
|
|
|
|
descriptor->ClearCacheEntry();
|
|
PR_REMOVE_AND_INIT_LINK(descriptor);
|
|
descriptor = nextDescriptor;
|
|
}
|
|
}
|
|
|
|
void nsCacheEntry::GetDescriptors(
|
|
nsTArray<RefPtr<nsCacheEntryDescriptor> >& outDescriptors) {
|
|
nsCacheEntryDescriptor* descriptor =
|
|
(nsCacheEntryDescriptor*)PR_LIST_HEAD(&mDescriptorQ);
|
|
|
|
while (descriptor != &mDescriptorQ) {
|
|
nsCacheEntryDescriptor* nextDescriptor =
|
|
(nsCacheEntryDescriptor*)PR_NEXT_LINK(descriptor);
|
|
|
|
outDescriptors.AppendElement(descriptor);
|
|
descriptor = nextDescriptor;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* nsCacheEntryInfo - for implementing about:cache
|
|
*****************************************************************************/
|
|
|
|
NS_IMPL_ISUPPORTS(nsCacheEntryInfo, nsICacheEntryInfo)
|
|
|
|
NS_IMETHODIMP
|
|
nsCacheEntryInfo::GetClientID(nsACString& aClientID) {
|
|
if (!mCacheEntry) {
|
|
aClientID.Truncate();
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
return ClientIDFromCacheKey(*mCacheEntry->Key(), aClientID);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsCacheEntryInfo::GetDeviceID(nsACString& aDeviceID) {
|
|
if (!mCacheEntry) {
|
|
aDeviceID.Truncate();
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
aDeviceID.Assign(mCacheEntry->GetDeviceID());
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsCacheEntryInfo::GetKey(nsACString& key) {
|
|
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
return ClientKeyFromCacheKey(*mCacheEntry->Key(), key);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsCacheEntryInfo::GetFetchCount(int32_t* fetchCount) {
|
|
NS_ENSURE_ARG_POINTER(fetchCount);
|
|
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
*fetchCount = mCacheEntry->FetchCount();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsCacheEntryInfo::GetLastFetched(uint32_t* lastFetched) {
|
|
NS_ENSURE_ARG_POINTER(lastFetched);
|
|
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
*lastFetched = mCacheEntry->LastFetched();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsCacheEntryInfo::GetLastModified(uint32_t* lastModified) {
|
|
NS_ENSURE_ARG_POINTER(lastModified);
|
|
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
*lastModified = mCacheEntry->LastModified();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsCacheEntryInfo::GetExpirationTime(uint32_t* expirationTime) {
|
|
NS_ENSURE_ARG_POINTER(expirationTime);
|
|
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
*expirationTime = mCacheEntry->ExpirationTime();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsCacheEntryInfo::GetDataSize(uint32_t* dataSize) {
|
|
NS_ENSURE_ARG_POINTER(dataSize);
|
|
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
*dataSize = mCacheEntry->DataSize();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsCacheEntryInfo::IsStreamBased(bool* result) {
|
|
NS_ENSURE_ARG_POINTER(result);
|
|
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
*result = mCacheEntry->IsStreamData();
|
|
return NS_OK;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* nsCacheEntryHashTable
|
|
*****************************************************************************/
|
|
|
|
const PLDHashTableOps nsCacheEntryHashTable::ops = {HashKey, MatchEntry,
|
|
MoveEntry, ClearEntry};
|
|
|
|
nsCacheEntryHashTable::nsCacheEntryHashTable()
|
|
: table(&ops, sizeof(nsCacheEntryHashTableEntry), kInitialTableLength),
|
|
initialized(false) {
|
|
MOZ_COUNT_CTOR(nsCacheEntryHashTable);
|
|
}
|
|
|
|
nsCacheEntryHashTable::~nsCacheEntryHashTable() {
|
|
MOZ_COUNT_DTOR(nsCacheEntryHashTable);
|
|
if (initialized) Shutdown();
|
|
}
|
|
|
|
void nsCacheEntryHashTable::Init() {
|
|
table.ClearAndPrepareForLength(kInitialTableLength);
|
|
initialized = true;
|
|
}
|
|
|
|
void nsCacheEntryHashTable::Shutdown() {
|
|
if (initialized) {
|
|
table.ClearAndPrepareForLength(kInitialTableLength);
|
|
initialized = false;
|
|
}
|
|
}
|
|
|
|
nsCacheEntry* nsCacheEntryHashTable::GetEntry(const nsCString* key) const {
|
|
NS_ASSERTION(initialized, "nsCacheEntryHashTable not initialized");
|
|
if (!initialized) return nullptr;
|
|
|
|
PLDHashEntryHdr* hashEntry = table.Search(key);
|
|
return hashEntry ? ((nsCacheEntryHashTableEntry*)hashEntry)->cacheEntry
|
|
: nullptr;
|
|
}
|
|
|
|
nsresult nsCacheEntryHashTable::AddEntry(nsCacheEntry* cacheEntry) {
|
|
PLDHashEntryHdr* hashEntry;
|
|
|
|
NS_ASSERTION(initialized, "nsCacheEntryHashTable not initialized");
|
|
if (!initialized) return NS_ERROR_NOT_INITIALIZED;
|
|
if (!cacheEntry) return NS_ERROR_NULL_POINTER;
|
|
|
|
hashEntry = table.Add(&(cacheEntry->mKey), fallible);
|
|
|
|
if (!hashEntry) return NS_ERROR_FAILURE;
|
|
NS_ASSERTION(((nsCacheEntryHashTableEntry*)hashEntry)->cacheEntry == nullptr,
|
|
"### nsCacheEntryHashTable::AddEntry - entry already used");
|
|
((nsCacheEntryHashTableEntry*)hashEntry)->cacheEntry = cacheEntry;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void nsCacheEntryHashTable::RemoveEntry(nsCacheEntry* cacheEntry) {
|
|
NS_ASSERTION(initialized, "nsCacheEntryHashTable not initialized");
|
|
NS_ASSERTION(cacheEntry, "### cacheEntry == nullptr");
|
|
|
|
if (!initialized) return; // NS_ERROR_NOT_INITIALIZED
|
|
|
|
#if DEBUG
|
|
// XXX debug code to make sure we have the entry we're trying to remove
|
|
nsCacheEntry* check = GetEntry(&(cacheEntry->mKey));
|
|
NS_ASSERTION(check == cacheEntry,
|
|
"### Attempting to remove unknown cache entry!!!");
|
|
#endif
|
|
table.Remove(&(cacheEntry->mKey));
|
|
}
|
|
|
|
PLDHashTable::Iterator nsCacheEntryHashTable::Iter() {
|
|
return PLDHashTable::Iterator(&table);
|
|
}
|
|
|
|
/**
|
|
* hash table operation callback functions
|
|
*/
|
|
|
|
PLDHashNumber nsCacheEntryHashTable::HashKey(const void* key) {
|
|
return HashString(*static_cast<const nsCString*>(key));
|
|
}
|
|
|
|
bool nsCacheEntryHashTable::MatchEntry(const PLDHashEntryHdr* hashEntry,
|
|
const void* key) {
|
|
NS_ASSERTION(key != nullptr,
|
|
"### nsCacheEntryHashTable::MatchEntry : null key");
|
|
nsCacheEntry* cacheEntry =
|
|
((nsCacheEntryHashTableEntry*)hashEntry)->cacheEntry;
|
|
|
|
return cacheEntry->mKey.Equals(*(nsCString*)key);
|
|
}
|
|
|
|
void nsCacheEntryHashTable::MoveEntry(PLDHashTable* /* table */,
|
|
const PLDHashEntryHdr* from,
|
|
PLDHashEntryHdr* to) {
|
|
new (KnownNotNull, to) nsCacheEntryHashTableEntry(
|
|
std::move(*((nsCacheEntryHashTableEntry*)from)));
|
|
// No need to destroy `from`.
|
|
}
|
|
|
|
void nsCacheEntryHashTable::ClearEntry(PLDHashTable* /* table */,
|
|
PLDHashEntryHdr* hashEntry) {
|
|
((nsCacheEntryHashTableEntry*)hashEntry)->cacheEntry = nullptr;
|
|
}
|