wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-10-23 15:47:30 +09:00
Code Issues Projects Releases Packages Wiki Activity

Remove telemetry from cache v1 service locking (part2).

Browse source 
- Fold Lock(TelemetryID) into Lock();
- Fold nsCacheServiceAutoLock(TelemetryID) into nsCacheServiceAutoLock();

Tag #21.
This commit is contained in:
wolfbeast 2018-10-01 11:31:29 +02:00 • committed by Roy Tam
commit 4e119039ec
3 changed files with 65 additions and 81 deletions
Download patch file Download diff file Expand all files Collapse all files

83
netwerk/cache/nsCacheEntryDescriptor.cpp vendored
View file

@ -43,7 +43,7 @@ public:
nsresult status = NS_OK; nsresult status = NS_OK;
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSASYNCDOOMEVENT_RUN)); nsCacheServiceAutoLock lock;
if (mDescriptor->mCacheEntry) { if (mDescriptor->mCacheEntry) {
status = nsCacheService::gService->DoomEntry_Internal( status = nsCacheService::gService->DoomEntry_Internal(
@ -113,7 +113,7 @@ nsCacheEntryDescriptor::GetClientID(char ** result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETCLIENTID)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
return ClientIDFromCacheKey(*(mCacheEntry->Key()), result); return ClientIDFromCacheKey(*(mCacheEntry->Key()), result);
@ -124,7 +124,7 @@ NS_IMETHODIMP
nsCacheEntryDescriptor::GetDeviceID(char ** aDeviceID) nsCacheEntryDescriptor::GetDeviceID(char ** aDeviceID)
{ {
NS_ENSURE_ARG_POINTER(aDeviceID); NS_ENSURE_ARG_POINTER(aDeviceID);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETDEVICEID)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
const char* deviceID = mCacheEntry->GetDeviceID(); const char* deviceID = mCacheEntry->GetDeviceID();
@ -141,7 +141,7 @@ nsCacheEntryDescriptor::GetDeviceID(char ** aDeviceID)
NS_IMETHODIMP NS_IMETHODIMP
nsCacheEntryDescriptor::GetKey(nsACString &result) nsCacheEntryDescriptor::GetKey(nsACString &result)
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETKEY)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
return ClientKeyFromCacheKey(*(mCacheEntry->Key()), result); return ClientKeyFromCacheKey(*(mCacheEntry->Key()), result);
@ -152,7 +152,7 @@ NS_IMETHODIMP
nsCacheEntryDescriptor::GetFetchCount(int32_t *result) nsCacheEntryDescriptor::GetFetchCount(int32_t *result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETFETCHCOUNT)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
*result = mCacheEntry->FetchCount(); *result = mCacheEntry->FetchCount();
@ -164,7 +164,7 @@ NS_IMETHODIMP
nsCacheEntryDescriptor::GetLastFetched(uint32_t *result) nsCacheEntryDescriptor::GetLastFetched(uint32_t *result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETLASTFETCHED)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
*result = mCacheEntry->LastFetched(); *result = mCacheEntry->LastFetched();
@ -176,7 +176,7 @@ NS_IMETHODIMP
nsCacheEntryDescriptor::GetLastModified(uint32_t *result) nsCacheEntryDescriptor::GetLastModified(uint32_t *result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETLASTMODIFIED)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
*result = mCacheEntry->LastModified(); *result = mCacheEntry->LastModified();
@ -188,7 +188,7 @@ NS_IMETHODIMP
nsCacheEntryDescriptor::GetExpirationTime(uint32_t *result) nsCacheEntryDescriptor::GetExpirationTime(uint32_t *result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETEXPIRATIONTIME)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
*result = mCacheEntry->ExpirationTime(); *result = mCacheEntry->ExpirationTime();
@ -199,7 +199,7 @@ nsCacheEntryDescriptor::GetExpirationTime(uint32_t *result)
NS_IMETHODIMP NS_IMETHODIMP
nsCacheEntryDescriptor::SetExpirationTime(uint32_t expirationTime) nsCacheEntryDescriptor::SetExpirationTime(uint32_t expirationTime)
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETEXPIRATIONTIME)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
mCacheEntry->SetExpirationTime(expirationTime); mCacheEntry->SetExpirationTime(expirationTime);
@ -211,7 +211,7 @@ nsCacheEntryDescriptor::SetExpirationTime(uint32_t expirationTime)
NS_IMETHODIMP nsCacheEntryDescriptor::IsStreamBased(bool *result) NS_IMETHODIMP nsCacheEntryDescriptor::IsStreamBased(bool *result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_ISSTREAMBASED)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
*result = mCacheEntry->IsStreamData(); *result = mCacheEntry->IsStreamData();
@ -221,7 +221,7 @@ NS_IMETHODIMP nsCacheEntryDescriptor::IsStreamBased(bool *result)
NS_IMETHODIMP nsCacheEntryDescriptor::GetPredictedDataSize(int64_t *result) NS_IMETHODIMP nsCacheEntryDescriptor::GetPredictedDataSize(int64_t *result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETPREDICTEDDATASIZE)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
*result = mCacheEntry->PredictedDataSize(); *result = mCacheEntry->PredictedDataSize();
@ -231,7 +231,7 @@ NS_IMETHODIMP nsCacheEntryDescriptor::GetPredictedDataSize(int64_t *result)
NS_IMETHODIMP nsCacheEntryDescriptor::SetPredictedDataSize(int64_t NS_IMETHODIMP nsCacheEntryDescriptor::SetPredictedDataSize(int64_t
predictedSize) predictedSize)
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETPREDICTEDDATASIZE)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
mCacheEntry->SetPredictedDataSize(predictedSize); mCacheEntry->SetPredictedDataSize(predictedSize);
@ -241,7 +241,7 @@ NS_IMETHODIMP nsCacheEntryDescriptor::SetPredictedDataSize(int64_t
NS_IMETHODIMP nsCacheEntryDescriptor::GetDataSize(uint32_t *result) NS_IMETHODIMP nsCacheEntryDescriptor::GetDataSize(uint32_t *result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETDATASIZE)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
const char* val = mCacheEntry->GetMetaDataElement("uncompressed-len"); const char* val = mCacheEntry->GetMetaDataElement("uncompressed-len");
@ -258,7 +258,7 @@ NS_IMETHODIMP nsCacheEntryDescriptor::GetDataSize(uint32_t *result)
NS_IMETHODIMP nsCacheEntryDescriptor::GetStorageDataSize(uint32_t *result) NS_IMETHODIMP nsCacheEntryDescriptor::GetStorageDataSize(uint32_t *result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETSTORAGEDATASIZE)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
*result = mCacheEntry->DataSize(); *result = mCacheEntry->DataSize();
@ -270,7 +270,7 @@ NS_IMETHODIMP nsCacheEntryDescriptor::GetStorageDataSize(uint32_t *result)
nsresult nsresult
nsCacheEntryDescriptor::RequestDataSizeChange(int32_t deltaSize) nsCacheEntryDescriptor::RequestDataSizeChange(int32_t deltaSize)
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_REQUESTDATASIZECHANGE)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
nsresult rv; nsresult rv;
@ -288,7 +288,7 @@ nsCacheEntryDescriptor::RequestDataSizeChange(int32_t deltaSize)
NS_IMETHODIMP NS_IMETHODIMP
nsCacheEntryDescriptor::SetDataSize(uint32_t dataSize) nsCacheEntryDescriptor::SetDataSize(uint32_t dataSize)
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETDATASIZE)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
// XXX review for signed/unsigned math errors // XXX review for signed/unsigned math errors
@ -317,7 +317,7 @@ nsCacheEntryDescriptor::OpenInputStream(uint32_t offset, nsIInputStream ** resul
nsInputStreamWrapper* cacheInput = nullptr; nsInputStreamWrapper* cacheInput = nullptr;
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_OPENINPUTSTREAM)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
if (!mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_NOT_STREAM; if (!mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_NOT_STREAM;
@ -352,7 +352,7 @@ nsCacheEntryDescriptor::OpenOutputStream(uint32_t offset, nsIOutputStream ** res
nsOutputStreamWrapper* cacheOutput = nullptr; nsOutputStreamWrapper* cacheOutput = nullptr;
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_OPENOUTPUTSTREAM)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
if (!mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_NOT_STREAM; if (!mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_NOT_STREAM;
@ -390,7 +390,7 @@ NS_IMETHODIMP
nsCacheEntryDescriptor::GetCacheElement(nsISupports ** result) nsCacheEntryDescriptor::GetCacheElement(nsISupports ** result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETCACHEELEMENT)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
if (mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_STREAM; if (mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_STREAM;
@ -402,7 +402,7 @@ nsCacheEntryDescriptor::GetCacheElement(nsISupports ** result)
NS_IMETHODIMP NS_IMETHODIMP
nsCacheEntryDescriptor::SetCacheElement(nsISupports * cacheElement) nsCacheEntryDescriptor::SetCacheElement(nsISupports * cacheElement)
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETCACHEELEMENT)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
if (mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_STREAM; if (mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_STREAM;
@ -423,7 +423,7 @@ NS_IMETHODIMP
nsCacheEntryDescriptor::GetStoragePolicy(nsCacheStoragePolicy *result) nsCacheEntryDescriptor::GetStoragePolicy(nsCacheStoragePolicy *result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETSTORAGEPOLICY)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
*result = mCacheEntry->StoragePolicy(); *result = mCacheEntry->StoragePolicy();
@ -434,7 +434,7 @@ nsCacheEntryDescriptor::GetStoragePolicy(nsCacheStoragePolicy *result)
NS_IMETHODIMP NS_IMETHODIMP
nsCacheEntryDescriptor::SetStoragePolicy(nsCacheStoragePolicy policy) nsCacheEntryDescriptor::SetStoragePolicy(nsCacheStoragePolicy policy)
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETSTORAGEPOLICY)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
// XXX validate policy against session? // XXX validate policy against session?
@ -461,7 +461,7 @@ NS_IMETHODIMP
nsCacheEntryDescriptor::GetFile(nsIFile ** result) nsCacheEntryDescriptor::GetFile(nsIFile ** result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETFILE)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
return nsCacheService::GetFileForEntry(mCacheEntry, result); return nsCacheService::GetFileForEntry(mCacheEntry, result);
@ -472,7 +472,7 @@ NS_IMETHODIMP
nsCacheEntryDescriptor::GetSecurityInfo(nsISupports ** result) nsCacheEntryDescriptor::GetSecurityInfo(nsISupports ** result)
{ {
NS_ENSURE_ARG_POINTER(result); NS_ENSURE_ARG_POINTER(result);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETSECURITYINFO)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
*result = mCacheEntry->SecurityInfo(); *result = mCacheEntry->SecurityInfo();
@ -484,7 +484,7 @@ nsCacheEntryDescriptor::GetSecurityInfo(nsISupports ** result)
NS_IMETHODIMP NS_IMETHODIMP
nsCacheEntryDescriptor::SetSecurityInfo(nsISupports * securityInfo) nsCacheEntryDescriptor::SetSecurityInfo(nsISupports * securityInfo)
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETSECURITYINFO)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
mCacheEntry->SetSecurityInfo(securityInfo); mCacheEntry->SetSecurityInfo(securityInfo);
@ -496,7 +496,7 @@ nsCacheEntryDescriptor::SetSecurityInfo(nsISupports * securityInfo)
NS_IMETHODIMP NS_IMETHODIMP
nsCacheEntryDescriptor::Doom() nsCacheEntryDescriptor::Doom()
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_DOOM)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
return nsCacheService::DoomEntry(mCacheEntry); return nsCacheService::DoomEntry(mCacheEntry);
@ -506,7 +506,7 @@ nsCacheEntryDescriptor::Doom()
NS_IMETHODIMP NS_IMETHODIMP
nsCacheEntryDescriptor::DoomAndFailPendingRequests(nsresult status) nsCacheEntryDescriptor::DoomAndFailPendingRequests(nsresult status)
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_DOOMANDFAILPENDINGREQUESTS)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
return NS_ERROR_NOT_IMPLEMENTED; return NS_ERROR_NOT_IMPLEMENTED;
@ -544,7 +544,7 @@ nsCacheEntryDescriptor::AsyncDoom(nsICacheListener *listener)
NS_IMETHODIMP NS_IMETHODIMP
nsCacheEntryDescriptor::MarkValid() nsCacheEntryDescriptor::MarkValid()
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_MARKVALID)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
nsresult rv = nsCacheService::ValidateEntry(mCacheEntry); nsresult rv = nsCacheService::ValidateEntry(mCacheEntry);
@ -559,7 +559,7 @@ nsCacheEntryDescriptor::Close()
nsTArray<RefPtr<nsInputStreamWrapper> > inputWrappers; nsTArray<RefPtr<nsInputStreamWrapper> > inputWrappers;
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_CLOSE)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
// Make sure no other stream can be opened // Make sure no other stream can be opened
@ -585,7 +585,7 @@ nsCacheEntryDescriptor::Close()
inputWrappers.Clear(); inputWrappers.Clear();
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_CLOSE)); nsCacheServiceAutoLock lock;
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
// XXX perhaps closing descriptors should clear/sever transports // XXX perhaps closing descriptors should clear/sever transports
@ -604,7 +604,7 @@ nsCacheEntryDescriptor::GetMetaDataElement(const char *key, char **result)
NS_ENSURE_ARG_POINTER(key); NS_ENSURE_ARG_POINTER(key);
*result = nullptr; *result = nullptr;
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETMETADATAELEMENT)); nsCacheServiceAutoLock lock;
NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_AVAILABLE); NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_AVAILABLE);
const char *value; const char *value;
@ -624,7 +624,7 @@ nsCacheEntryDescriptor::SetMetaDataElement(const char *key, const char *value)
{ {
NS_ENSURE_ARG_POINTER(key); NS_ENSURE_ARG_POINTER(key);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETMETADATAELEMENT)); nsCacheServiceAutoLock lock;
NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_AVAILABLE); NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_AVAILABLE);
// XXX allow null value, for clearing key? // XXX allow null value, for clearing key?
@ -639,7 +639,7 @@ nsCacheEntryDescriptor::SetMetaDataElement(const char *key, const char *value)
NS_IMETHODIMP NS_IMETHODIMP
nsCacheEntryDescriptor::VisitMetaData(nsICacheMetaDataVisitor * visitor) nsCacheEntryDescriptor::VisitMetaData(nsICacheMetaDataVisitor * visitor)
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_VISITMETADATA)); nsCacheServiceAutoLock lock;
// XXX check callers, we're calling out of module // XXX check callers, we're calling out of module
NS_ENSURE_ARG_POINTER(visitor); NS_ENSURE_ARG_POINTER(visitor);
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
@ -667,7 +667,7 @@ nsCacheEntryDescriptor::nsInputStreamWrapper::Release()
} }
if (desc) if (desc)
nsCacheService::Lock(LOCK_TELEM(NSINPUTSTREAMWRAPPER_RELEASE)); nsCacheService::Lock();
nsrefcnt count; nsrefcnt count;
NS_PRECONDITION(0 != mRefCnt, "dup release"); NS_PRECONDITION(0 != mRefCnt, "dup release");
@ -709,7 +709,7 @@ nsInputStreamWrapper::LazyInit()
if (!mDescriptor) if (!mDescriptor)
return NS_ERROR_NOT_AVAILABLE; return NS_ERROR_NOT_AVAILABLE;
nsCacheServiceAutoLock lock(LOCK_TELEM(NSINPUTSTREAMWRAPPER_LAZYINIT)); nsCacheServiceAutoLock lock;
nsCacheAccessMode mode; nsCacheAccessMode mode;
nsresult rv = mDescriptor->GetAccessGranted(&mode); nsresult rv = mDescriptor->GetAccessGranted(&mode);
@ -755,7 +755,7 @@ nsInputStreamWrapper::CloseInternal()
return; return;
} }
nsCacheServiceAutoLock lock(LOCK_TELEM(NSINPUTSTREAMWRAPPER_CLOSEINTERNAL)); nsCacheServiceAutoLock lock;
if (mDescriptor) { if (mDescriptor) {
mDescriptor->mInputWrappers.RemoveElement(this); mDescriptor->mInputWrappers.RemoveElement(this);
@ -859,8 +859,7 @@ nsCacheEntryDescriptor::nsDecompressInputStreamWrapper::Release()
} }
if (desc) if (desc)
nsCacheService::Lock(LOCK_TELEM( nsCacheService::Lock();
NSDECOMPRESSINPUTSTREAMWRAPPER_RELEASE));
nsrefcnt count; nsrefcnt count;
NS_PRECONDITION(0 != mRefCnt, "dup release"); NS_PRECONDITION(0 != mRefCnt, "dup release");
@ -1049,7 +1048,7 @@ nsCacheEntryDescriptor::nsOutputStreamWrapper::Release()
} }
if (desc) if (desc)
nsCacheService::Lock(LOCK_TELEM(NSOUTPUTSTREAMWRAPPER_RELEASE)); nsCacheService::Lock();
nsrefcnt count; nsrefcnt count;
NS_PRECONDITION(0 != mRefCnt, "dup release"); NS_PRECONDITION(0 != mRefCnt, "dup release");
@ -1089,7 +1088,7 @@ nsOutputStreamWrapper::LazyInit()
if (!mDescriptor) if (!mDescriptor)
return NS_ERROR_NOT_AVAILABLE; return NS_ERROR_NOT_AVAILABLE;
nsCacheServiceAutoLock lock(LOCK_TELEM(NSOUTPUTSTREAMWRAPPER_LAZYINIT)); nsCacheServiceAutoLock lock;
nsCacheAccessMode mode; nsCacheAccessMode mode;
nsresult rv = mDescriptor->GetAccessGranted(&mode); nsresult rv = mDescriptor->GetAccessGranted(&mode);
@ -1163,7 +1162,7 @@ nsOutputStreamWrapper::CloseInternal()
return; return;
} }
nsCacheServiceAutoLock lock(LOCK_TELEM(NSOUTPUTSTREAMWRAPPER_CLOSEINTERNAL)); nsCacheServiceAutoLock lock;
if (mDescriptor) { if (mDescriptor) {
mDescriptor->mOutputWrapper = nullptr; mDescriptor->mOutputWrapper = nullptr;
@ -1279,7 +1278,7 @@ nsCacheEntryDescriptor::nsCompressOutputStreamWrapper::Release()
} }
if (desc) if (desc)
nsCacheService::Lock(LOCK_TELEM(NSCOMPRESSOUTPUTSTREAMWRAPPER_RELEASE)); nsCacheService::Lock();
nsrefcnt count; nsrefcnt count;
NS_PRECONDITION(0 != mRefCnt, "dup release"); NS_PRECONDITION(0 != mRefCnt, "dup release");

57
netwerk/cache/nsCacheService.cpp vendored
View file

@ -211,7 +211,7 @@ public:
NS_IMETHOD Notify(nsITimer* aTimer) override { NS_IMETHOD Notify(nsITimer* aTimer) override {
if (nsCacheService::gService) { if (nsCacheService::gService) {
nsCacheServiceAutoLock autoLock(LOCK_TELEM(NSSETDISKSMARTSIZECALLBACK_NOTIFY)); nsCacheServiceAutoLock autoLock;
nsCacheService::gService->SetDiskSmartSize_Locked(); nsCacheService::gService->SetDiskSmartSize_Locked();
nsCacheService::gService->mSmartSizeTimer = nullptr; nsCacheService::gService->mSmartSizeTimer = nullptr;
} }
@ -295,7 +295,7 @@ public:
} }
NS_IMETHOD Run() override NS_IMETHOD Run() override
{ {
nsCacheServiceAutoLock autoLock(LOCK_TELEM(NSBLOCKONCACHETHREADEVENT_RUN)); nsCacheServiceAutoLock autoLock;
CACHE_LOG_DEBUG(("nsBlockOnCacheThreadEvent [%p]\n", this)); CACHE_LOG_DEBUG(("nsBlockOnCacheThreadEvent [%p]\n", this));
nsCacheService::gService->mNotified = true; nsCacheService::gService->mNotified = true;
nsCacheService::gService->mCondVar.Notify(); nsCacheService::gService->mCondVar.Notify();
@ -988,7 +988,7 @@ public:
NS_ASSERTION(mRequest->mListener, NS_ASSERTION(mRequest->mListener,
"Sync OpenCacheEntry() posted to background thread!"); "Sync OpenCacheEntry() posted to background thread!");
nsCacheServiceAutoLock lock(LOCK_TELEM(NSPROCESSREQUESTEVENT_RUN)); nsCacheServiceAutoLock lock;
rv = nsCacheService::gService->ProcessRequest(mRequest, rv = nsCacheService::gService->ProcessRequest(mRequest,
false, false,
nullptr); nullptr);
@ -1189,7 +1189,7 @@ nsCacheService::Shutdown()
nsCOMPtr<nsIFile> parentDir; nsCOMPtr<nsIFile> parentDir;
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SHUTDOWN)); nsCacheServiceAutoLock lock;
NS_ASSERTION(mInitialized, NS_ASSERTION(mInitialized,
"can't shutdown nsCacheService unless it has been initialized."); "can't shutdown nsCacheService unless it has been initialized.");
if (!mInitialized) if (!mInitialized)
@ -1204,7 +1204,7 @@ nsCacheService::Shutdown()
UnregisterWeakMemoryReporter(this); UnregisterWeakMemoryReporter(this);
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SHUTDOWN)); nsCacheServiceAutoLock lock;
NS_ASSERTION(mInitialized, "Bad state"); NS_ASSERTION(mInitialized, "Bad state");
mInitialized = false; mInitialized = false;
@ -1363,7 +1363,7 @@ nsCacheService::EvictEntriesForClient(const char * clientID,
new EvictionNotifierRunnable(NS_ISUPPORTS_CAST(nsICacheService*, this)); new EvictionNotifierRunnable(NS_ISUPPORTS_CAST(nsICacheService*, this));
NS_DispatchToMainThread(r); NS_DispatchToMainThread(r);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_EVICTENTRIESFORCLIENT)); nsCacheServiceAutoLock lock;
nsresult res = NS_OK; nsresult res = NS_OK;
if (storagePolicy == nsICache::STORE_ANYWHERE || if (storagePolicy == nsICache::STORE_ANYWHERE ||
@ -1412,7 +1412,7 @@ nsCacheService::IsStorageEnabledForPolicy(nsCacheStoragePolicy storagePolicy,
bool * result) bool * result)
{ {
if (gService == nullptr) return NS_ERROR_NOT_AVAILABLE; if (gService == nullptr) return NS_ERROR_NOT_AVAILABLE;
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_ISSTORAGEENABLEDFORPOLICY)); nsCacheServiceAutoLock lock;
*result = gService->IsStorageEnabledForPolicy_Locked(storagePolicy); *result = gService->IsStorageEnabledForPolicy_Locked(storagePolicy);
return NS_OK; return NS_OK;
@ -1466,7 +1466,7 @@ nsresult nsCacheService::VisitEntriesInternal(nsICacheVisitor *visitor)
{ {
NS_ENSURE_ARG_POINTER(visitor); NS_ENSURE_ARG_POINTER(visitor);
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_VISITENTRIES)); nsCacheServiceAutoLock lock;
if (!(mEnableDiskDevice || mEnableMemoryDevice)) if (!(mEnableDiskDevice || mEnableMemoryDevice))
return NS_ERROR_NOT_AVAILABLE; return NS_ERROR_NOT_AVAILABLE;
@ -1548,7 +1548,7 @@ NS_IMETHODIMP nsCacheService::GetCacheIOTarget(nsIEventTarget * *aCacheIOTarget)
// read from the main thread without the lock. This is useful to prevent // read from the main thread without the lock. This is useful to prevent
// blocking the main thread on other cache operations. // blocking the main thread on other cache operations.
if (!NS_IsMainThread()) { if (!NS_IsMainThread()) {
Lock(LOCK_TELEM(NSCACHESERVICE_GETCACHEIOTARGET)); Lock();
} }
nsresult rv; nsresult rv;
@ -1940,7 +1940,7 @@ nsCacheService::ProcessRequest(nsCacheRequest * request,
// XXX this is probably wrong... // XXX this is probably wrong...
Unlock(); Unlock();
rv = request->WaitForValidation(); rv = request->WaitForValidation();
Lock(LOCK_TELEM(NSCACHESERVICE_PROCESSREQUEST)); Lock();
} }
PR_REMOVE_AND_INIT_LINK(request); PR_REMOVE_AND_INIT_LINK(request);
@ -2052,7 +2052,7 @@ nsCacheService::OpenCacheEntry(nsCacheSession * session,
} }
else { else {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_OPENCACHEENTRY)); nsCacheServiceAutoLock lock;
rv = gService->ProcessRequest(request, true, result); rv = gService->ProcessRequest(request, true, result);
// delete requests that have completed // delete requests that have completed
@ -2353,14 +2353,14 @@ nsCacheService::OnProfileShutdown()
} }
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_ONPROFILESHUTDOWN)); nsCacheServiceAutoLock lock;
gService->mClearingEntries = true; gService->mClearingEntries = true;
gService->DoomActiveEntries(nullptr); gService->DoomActiveEntries(nullptr);
} }
gService->CloseAllStreams(); gService->CloseAllStreams();
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_ONPROFILESHUTDOWN)); nsCacheServiceAutoLock lock;
gService->ClearDoomList(); gService->ClearDoomList();
// Make sure to wait for any pending cache-operations before // Make sure to wait for any pending cache-operations before
@ -2399,7 +2399,7 @@ nsCacheService::OnProfileChanged()
CACHE_LOG_DEBUG(("nsCacheService::OnProfileChanged")); CACHE_LOG_DEBUG(("nsCacheService::OnProfileChanged"));
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_ONPROFILECHANGED)); nsCacheServiceAutoLock lock;
gService->mEnableDiskDevice = gService->mObserver->DiskCacheEnabled(); gService->mEnableDiskDevice = gService->mObserver->DiskCacheEnabled();
gService->mEnableOfflineDevice = gService->mObserver->OfflineCacheEnabled(); gService->mEnableOfflineDevice = gService->mObserver->OfflineCacheEnabled();
@ -2453,7 +2453,7 @@ void
nsCacheService::SetDiskCacheEnabled(bool enabled) nsCacheService::SetDiskCacheEnabled(bool enabled)
{ {
if (!gService) return; if (!gService) return;
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETDISKCACHEENABLED)); nsCacheServiceAutoLock lock;
gService->mEnableDiskDevice = enabled; gService->mEnableDiskDevice = enabled;
} }
@ -2462,7 +2462,7 @@ void
nsCacheService::SetDiskCacheCapacity(int32_t capacity) nsCacheService::SetDiskCacheCapacity(int32_t capacity)
{ {
if (!gService) return; if (!gService) return;
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETDISKCACHECAPACITY)); nsCacheServiceAutoLock lock;
if (gService->mDiskDevice) { if (gService->mDiskDevice) {
gService->mDiskDevice->SetCapacity(capacity); gService->mDiskDevice->SetCapacity(capacity);
@ -2475,7 +2475,7 @@ void
nsCacheService::SetDiskCacheMaxEntrySize(int32_t maxSize) nsCacheService::SetDiskCacheMaxEntrySize(int32_t maxSize)
{ {
if (!gService) return; if (!gService) return;
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETDISKCACHEMAXENTRYSIZE)); nsCacheServiceAutoLock lock;
if (gService->mDiskDevice) { if (gService->mDiskDevice) {
gService->mDiskDevice->SetMaxEntrySize(maxSize); gService->mDiskDevice->SetMaxEntrySize(maxSize);
@ -2486,7 +2486,7 @@ void
nsCacheService::SetMemoryCacheMaxEntrySize(int32_t maxSize) nsCacheService::SetMemoryCacheMaxEntrySize(int32_t maxSize)
{ {
if (!gService) return; if (!gService) return;
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETMEMORYCACHEMAXENTRYSIZE)); nsCacheServiceAutoLock lock;
if (gService->mMemoryDevice) { if (gService->mMemoryDevice) {
gService->mMemoryDevice->SetMaxEntrySize(maxSize); gService->mMemoryDevice->SetMaxEntrySize(maxSize);
@ -2497,7 +2497,7 @@ void
nsCacheService::SetOfflineCacheEnabled(bool enabled) nsCacheService::SetOfflineCacheEnabled(bool enabled)
{ {
if (!gService) return; if (!gService) return;
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETOFFLINECACHEENABLED)); nsCacheServiceAutoLock lock;
gService->mEnableOfflineDevice = enabled; gService->mEnableOfflineDevice = enabled;
} }
@ -2505,7 +2505,7 @@ void
nsCacheService::SetOfflineCacheCapacity(int32_t capacity) nsCacheService::SetOfflineCacheCapacity(int32_t capacity)
{ {
if (!gService) return; if (!gService) return;
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETOFFLINECACHECAPACITY)); nsCacheServiceAutoLock lock;
if (gService->mOfflineDevice) { if (gService->mOfflineDevice) {
gService->mOfflineDevice->SetCapacity(capacity); gService->mOfflineDevice->SetCapacity(capacity);
@ -2522,7 +2522,7 @@ nsCacheService::SetMemoryCache()
CACHE_LOG_DEBUG(("nsCacheService::SetMemoryCache")); CACHE_LOG_DEBUG(("nsCacheService::SetMemoryCache"));
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETMEMORYCACHE)); nsCacheServiceAutoLock lock;
gService->mEnableMemoryDevice = gService->mObserver->MemoryCacheEnabled(); gService->mEnableMemoryDevice = gService->mObserver->MemoryCacheEnabled();
@ -2637,14 +2637,6 @@ nsCacheService::Lock()
gService->LockAcquired(); gService->LockAcquired();
} }
void
nsCacheService::Lock(mozilla::Telemetry::ID mainThreadLockerID)
{
// Telemetry data removed.
// XXX: Fold into nsCacheService::Lock()
nsCacheService::Lock();
}
void void
nsCacheService::Unlock() nsCacheService::Unlock()
{ {
@ -2924,7 +2916,7 @@ nsCacheService::CloseAllStreams()
nsTArray<RefPtr<nsCacheEntryDescriptor::nsOutputStreamWrapper> > outputs; nsTArray<RefPtr<nsCacheEntryDescriptor::nsOutputStreamWrapper> > outputs;
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_CLOSEALLSTREAMS)); nsCacheServiceAutoLock lock;
nsTArray<nsCacheEntry*> entries; nsTArray<nsCacheEntry*> entries;
@ -3047,7 +3039,7 @@ nsCacheService::LogCacheStatistics()
nsresult nsresult
nsCacheService::SetDiskSmartSize() nsCacheService::SetDiskSmartSize()
{ {
nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETDISKSMARTSIZE)); nsCacheServiceAutoLock lock;
if (!gService) return NS_ERROR_NOT_AVAILABLE; if (!gService) return NS_ERROR_NOT_AVAILABLE;
@ -3166,8 +3158,7 @@ nsCacheService::CollectReports(nsIHandleReportCallback* aHandleReport,
{ {
size_t disk = 0; size_t disk = 0;
if (mDiskDevice) { if (mDiskDevice) {
nsCacheServiceAutoLock nsCacheServiceAutoLock lock;
lock(LOCK_TELEM(NSCACHESERVICE_DISKDEVICEHEAPSIZE));
disk = mDiskDevice->SizeOfIncludingThis(DiskCacheDeviceMallocSizeOf); disk = mDiskDevice->SizeOfIncludingThis(DiskCacheDeviceMallocSizeOf);
} }

6
netwerk/cache/nsCacheService.h vendored
View file

@ -371,9 +371,6 @@ private:
* nsCacheServiceAutoLock * nsCacheServiceAutoLock
******************************************************************************/ ******************************************************************************/
#define LOCK_TELEM(x) \
(::mozilla::Telemetry::CACHE_SERVICE_LOCK_WAIT_MAINTHREAD_##x)
// Instantiate this class to acquire the cache service lock for a particular // Instantiate this class to acquire the cache service lock for a particular
// execution scope. // execution scope.
class nsCacheServiceAutoLock { class nsCacheServiceAutoLock {
@ -381,9 +378,6 @@ public:
nsCacheServiceAutoLock() { nsCacheServiceAutoLock() {
nsCacheService::Lock(); nsCacheService::Lock();
} }
explicit nsCacheServiceAutoLock(mozilla::Telemetry::ID mainThreadLockerID) {
nsCacheService::Lock(mainThreadLockerID);
}
~nsCacheServiceAutoLock() { ~nsCacheServiceAutoLock() {
nsCacheService::Unlock(); nsCacheService::Unlock();
} }