зеркало из https://github.com/mozilla/gecko-dev.git
720 строки
19 KiB
C++
720 строки
19 KiB
C++
/* 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 "CacheLog.h"
|
|
#include "CacheFileInputStream.h"
|
|
|
|
#include "CacheFile.h"
|
|
#include "nsStreamUtils.h"
|
|
#include "nsThreadUtils.h"
|
|
#include <algorithm>
|
|
|
|
namespace mozilla::net {
|
|
|
|
NS_IMPL_ADDREF(CacheFileInputStream)
|
|
NS_IMETHODIMP_(MozExternalRefCountType)
|
|
CacheFileInputStream::Release() {
|
|
MOZ_ASSERT(0 != mRefCnt, "dup release");
|
|
nsrefcnt count = --mRefCnt;
|
|
NS_LOG_RELEASE(this, count, "CacheFileInputStream");
|
|
|
|
if (0 == count) {
|
|
mRefCnt = 1;
|
|
delete (this);
|
|
return 0;
|
|
}
|
|
|
|
if (count == 1) {
|
|
CacheFileAutoLock lock(mFile);
|
|
mFile->RemoveInput(this, mStatus);
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
NS_INTERFACE_MAP_BEGIN(CacheFileInputStream)
|
|
NS_INTERFACE_MAP_ENTRY(nsIInputStream)
|
|
NS_INTERFACE_MAP_ENTRY(nsIAsyncInputStream)
|
|
NS_INTERFACE_MAP_ENTRY(nsISeekableStream)
|
|
NS_INTERFACE_MAP_ENTRY(nsITellableStream)
|
|
NS_INTERFACE_MAP_ENTRY(mozilla::net::CacheFileChunkListener)
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStream)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
CacheFileInputStream::CacheFileInputStream(CacheFile* aFile,
|
|
nsISupports* aEntry,
|
|
bool aAlternativeData)
|
|
: mFile(aFile),
|
|
mPos(0),
|
|
mStatus(NS_OK),
|
|
mClosed(false),
|
|
mInReadSegments(false),
|
|
mWaitingForUpdate(false),
|
|
mAlternativeData(aAlternativeData),
|
|
mListeningForChunk(-1),
|
|
mCallbackFlags(0),
|
|
mCacheEntryHandle(aEntry) {
|
|
LOG(("CacheFileInputStream::CacheFileInputStream() [this=%p]", this));
|
|
|
|
if (mAlternativeData) {
|
|
mPos = mFile->mAltDataOffset;
|
|
}
|
|
}
|
|
|
|
CacheFileInputStream::~CacheFileInputStream() {
|
|
LOG(("CacheFileInputStream::~CacheFileInputStream() [this=%p]", this));
|
|
MOZ_ASSERT(!mInReadSegments);
|
|
}
|
|
|
|
// nsIInputStream
|
|
NS_IMETHODIMP
|
|
CacheFileInputStream::Close() {
|
|
LOG(("CacheFileInputStream::Close() [this=%p]", this));
|
|
return CloseWithStatus(NS_OK);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CacheFileInputStream::Available(uint64_t* _retval) {
|
|
CacheFileAutoLock lock(mFile);
|
|
|
|
if (mClosed) {
|
|
LOG(
|
|
("CacheFileInputStream::Available() - Stream is closed. [this=%p, "
|
|
"status=0x%08" PRIx32 "]",
|
|
this, static_cast<uint32_t>(mStatus)));
|
|
return NS_FAILED(mStatus) ? mStatus : NS_BASE_STREAM_CLOSED;
|
|
}
|
|
|
|
EnsureCorrectChunk(false);
|
|
if (NS_FAILED(mStatus)) {
|
|
LOG(
|
|
("CacheFileInputStream::Available() - EnsureCorrectChunk failed. "
|
|
"[this=%p, status=0x%08" PRIx32 "]",
|
|
this, static_cast<uint32_t>(mStatus)));
|
|
return mStatus;
|
|
}
|
|
|
|
nsresult rv = NS_OK;
|
|
*_retval = 0;
|
|
|
|
if (mChunk) {
|
|
int64_t canRead = mFile->BytesFromChunk(mChunk->Index(), mAlternativeData);
|
|
canRead -= (mPos % kChunkSize);
|
|
|
|
if (canRead > 0) {
|
|
*_retval = canRead;
|
|
} else if (canRead == 0 && !mFile->OutputStreamExists(mAlternativeData)) {
|
|
rv = NS_BASE_STREAM_CLOSED;
|
|
}
|
|
}
|
|
|
|
LOG(("CacheFileInputStream::Available() [this=%p, retval=%" PRIu64
|
|
", rv=0x%08" PRIx32 "]",
|
|
this, *_retval, static_cast<uint32_t>(rv)));
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CacheFileInputStream::Read(char* aBuf, uint32_t aCount, uint32_t* _retval) {
|
|
LOG(("CacheFileInputStream::Read() [this=%p, count=%d]", this, aCount));
|
|
return ReadSegments(NS_CopySegmentToBuffer, aBuf, aCount, _retval);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CacheFileInputStream::ReadSegments(nsWriteSegmentFun aWriter, void* aClosure,
|
|
uint32_t aCount, uint32_t* _retval) {
|
|
CacheFileAutoLock lock(mFile);
|
|
|
|
LOG(("CacheFileInputStream::ReadSegments() [this=%p, count=%d]", this,
|
|
aCount));
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
*_retval = 0;
|
|
|
|
if (mInReadSegments) {
|
|
LOG(
|
|
("CacheFileInputStream::ReadSegments() - Cannot be called while the "
|
|
"stream is in ReadSegments!"));
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
if (mClosed) {
|
|
LOG(
|
|
("CacheFileInputStream::ReadSegments() - Stream is closed. [this=%p, "
|
|
"status=0x%08" PRIx32 "]",
|
|
this, static_cast<uint32_t>(mStatus)));
|
|
|
|
if (NS_FAILED(mStatus)) {
|
|
return mStatus;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aCount == 0) {
|
|
return NS_OK;
|
|
}
|
|
|
|
EnsureCorrectChunk(false);
|
|
|
|
while (true) {
|
|
if (NS_FAILED(mStatus)) return mStatus;
|
|
|
|
if (!mChunk) {
|
|
if (mListeningForChunk == -1) {
|
|
return NS_OK;
|
|
}
|
|
return NS_BASE_STREAM_WOULD_BLOCK;
|
|
}
|
|
|
|
CacheFileChunkReadHandle hnd = mChunk->GetReadHandle();
|
|
int64_t canRead = CanRead(&hnd);
|
|
if (NS_FAILED(mStatus)) {
|
|
return mStatus;
|
|
}
|
|
|
|
if (canRead < 0) {
|
|
// file was truncated ???
|
|
MOZ_ASSERT(false, "SetEOF is currenty not implemented?!");
|
|
rv = NS_OK;
|
|
} else if (canRead > 0) {
|
|
uint32_t toRead = std::min(static_cast<uint32_t>(canRead), aCount);
|
|
uint32_t read;
|
|
const char* buf = hnd.Buf() + (mPos - hnd.Offset());
|
|
|
|
mInReadSegments = true;
|
|
lock.Unlock();
|
|
|
|
rv = aWriter(this, aClosure, buf, *_retval, toRead, &read);
|
|
|
|
lock.Lock();
|
|
mInReadSegments = false;
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
MOZ_ASSERT(read <= toRead,
|
|
"writer should not write more than we asked it to write");
|
|
|
|
*_retval += read;
|
|
mPos += read;
|
|
aCount -= read;
|
|
|
|
if (!mClosed) {
|
|
// The last chunk is released after the caller closes this stream.
|
|
EnsureCorrectChunk(false);
|
|
|
|
if (mChunk && aCount) {
|
|
// Check whether there is more data available to read.
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mClosed) {
|
|
// The stream was closed from aWriter, do the cleanup.
|
|
CleanUp();
|
|
}
|
|
|
|
rv = NS_OK;
|
|
} else {
|
|
if (*_retval == 0 && mFile->OutputStreamExists(mAlternativeData)) {
|
|
rv = NS_BASE_STREAM_WOULD_BLOCK;
|
|
} else {
|
|
rv = NS_OK;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
LOG(("CacheFileInputStream::ReadSegments() [this=%p, rv=0x%08" PRIx32
|
|
", retval=%d]",
|
|
this, static_cast<uint32_t>(rv), *_retval));
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CacheFileInputStream::IsNonBlocking(bool* _retval) {
|
|
*_retval = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
// nsIAsyncInputStream
|
|
NS_IMETHODIMP
|
|
CacheFileInputStream::CloseWithStatus(nsresult aStatus) {
|
|
CacheFileAutoLock lock(mFile);
|
|
|
|
LOG(("CacheFileInputStream::CloseWithStatus() [this=%p, aStatus=0x%08" PRIx32
|
|
"]",
|
|
this, static_cast<uint32_t>(aStatus)));
|
|
|
|
CloseWithStatusLocked(aStatus);
|
|
return NS_OK;
|
|
}
|
|
|
|
void CacheFileInputStream::CloseWithStatusLocked(nsresult aStatus) {
|
|
LOG(
|
|
("CacheFileInputStream::CloseWithStatusLocked() [this=%p, "
|
|
"aStatus=0x%08" PRIx32 "]",
|
|
this, static_cast<uint32_t>(aStatus)));
|
|
|
|
if (mClosed) {
|
|
// We notify listener and null out mCallback immediately after closing
|
|
// the stream. If we're in ReadSegments we postpone notification until we
|
|
// step out from ReadSegments. So if the stream is already closed the
|
|
// following assertion must be true.
|
|
MOZ_ASSERT(!mCallback || mInReadSegments);
|
|
return;
|
|
}
|
|
|
|
mClosed = true;
|
|
mStatus = NS_FAILED(aStatus) ? aStatus : NS_BASE_STREAM_CLOSED;
|
|
|
|
if (!mInReadSegments) {
|
|
CleanUp();
|
|
}
|
|
}
|
|
|
|
void CacheFileInputStream::CleanUp() {
|
|
MOZ_ASSERT(!mInReadSegments);
|
|
MOZ_ASSERT(mClosed);
|
|
|
|
if (mChunk) {
|
|
ReleaseChunk();
|
|
}
|
|
|
|
// TODO propagate error from input stream to other streams ???
|
|
|
|
MaybeNotifyListener();
|
|
|
|
mFile->ReleaseOutsideLock(std::move(mCacheEntryHandle));
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CacheFileInputStream::AsyncWait(nsIInputStreamCallback* aCallback,
|
|
uint32_t aFlags, uint32_t aRequestedCount,
|
|
nsIEventTarget* aEventTarget) {
|
|
CacheFileAutoLock lock(mFile);
|
|
|
|
LOG(
|
|
("CacheFileInputStream::AsyncWait() [this=%p, callback=%p, flags=%d, "
|
|
"requestedCount=%d, eventTarget=%p]",
|
|
this, aCallback, aFlags, aRequestedCount, aEventTarget));
|
|
|
|
if (mInReadSegments) {
|
|
LOG(
|
|
("CacheFileInputStream::AsyncWait() - Cannot be called while the stream"
|
|
" is in ReadSegments!"));
|
|
MOZ_ASSERT(false,
|
|
"Unexpected call. If it's a valid usage implement it. "
|
|
"Otherwise fix the caller.");
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
mCallback = aCallback;
|
|
mCallbackFlags = aFlags;
|
|
mCallbackTarget = aEventTarget;
|
|
|
|
if (!mCallback) {
|
|
if (mWaitingForUpdate) {
|
|
mChunk->CancelWait(this);
|
|
mWaitingForUpdate = false;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
if (mClosed) {
|
|
NotifyListener();
|
|
return NS_OK;
|
|
}
|
|
|
|
EnsureCorrectChunk(false);
|
|
|
|
MaybeNotifyListener();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// nsISeekableStream
|
|
NS_IMETHODIMP
|
|
CacheFileInputStream::Seek(int32_t whence, int64_t offset) {
|
|
CacheFileAutoLock lock(mFile);
|
|
mFile->AssertOwnsLock(); // For thread-safety analysis
|
|
|
|
LOG(("CacheFileInputStream::Seek() [this=%p, whence=%d, offset=%" PRId64 "]",
|
|
this, whence, offset));
|
|
|
|
if (mInReadSegments) {
|
|
LOG(
|
|
("CacheFileInputStream::Seek() - Cannot be called while the stream is "
|
|
"in ReadSegments!"));
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
if (mClosed) {
|
|
LOG(("CacheFileInputStream::Seek() - Stream is closed. [this=%p]", this));
|
|
return NS_BASE_STREAM_CLOSED;
|
|
}
|
|
|
|
int64_t newPos = offset;
|
|
switch (whence) {
|
|
case NS_SEEK_SET:
|
|
if (mAlternativeData) {
|
|
newPos += mFile->mAltDataOffset;
|
|
}
|
|
break;
|
|
case NS_SEEK_CUR:
|
|
newPos += mPos;
|
|
break;
|
|
case NS_SEEK_END:
|
|
if (mAlternativeData) {
|
|
newPos += mFile->mDataSize;
|
|
} else {
|
|
newPos += mFile->mAltDataOffset;
|
|
}
|
|
break;
|
|
default:
|
|
NS_ERROR("invalid whence");
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
mPos = newPos;
|
|
EnsureCorrectChunk(false);
|
|
|
|
LOG(("CacheFileInputStream::Seek() [this=%p, pos=%" PRId64 "]", this, mPos));
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CacheFileInputStream::SetEOF() {
|
|
MOZ_ASSERT(false, "Don't call SetEOF on cache input stream");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
// nsITellableStream
|
|
NS_IMETHODIMP
|
|
CacheFileInputStream::Tell(int64_t* _retval) {
|
|
CacheFileAutoLock lock(mFile);
|
|
mFile->AssertOwnsLock(); // For thread-safety analysis
|
|
|
|
if (mClosed) {
|
|
LOG(("CacheFileInputStream::Tell() - Stream is closed. [this=%p]", this));
|
|
return NS_BASE_STREAM_CLOSED;
|
|
}
|
|
|
|
*_retval = mPos;
|
|
|
|
if (mAlternativeData) {
|
|
*_retval -= mFile->mAltDataOffset;
|
|
}
|
|
|
|
LOG(("CacheFileInputStream::Tell() [this=%p, retval=%" PRId64 "]", this,
|
|
*_retval));
|
|
return NS_OK;
|
|
}
|
|
|
|
// CacheFileChunkListener
|
|
nsresult CacheFileInputStream::OnChunkRead(nsresult aResult,
|
|
CacheFileChunk* aChunk) {
|
|
MOZ_CRASH("CacheFileInputStream::OnChunkRead should not be called!");
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
nsresult CacheFileInputStream::OnChunkWritten(nsresult aResult,
|
|
CacheFileChunk* aChunk) {
|
|
MOZ_CRASH("CacheFileInputStream::OnChunkWritten should not be called!");
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
nsresult CacheFileInputStream::OnChunkAvailable(nsresult aResult,
|
|
uint32_t aChunkIdx,
|
|
CacheFileChunk* aChunk) {
|
|
CacheFileAutoLock lock(mFile);
|
|
|
|
LOG(("CacheFileInputStream::OnChunkAvailable() [this=%p, result=0x%08" PRIx32
|
|
", "
|
|
"idx=%d, chunk=%p]",
|
|
this, static_cast<uint32_t>(aResult), aChunkIdx, aChunk));
|
|
|
|
MOZ_ASSERT(mListeningForChunk != -1);
|
|
|
|
if (mListeningForChunk != static_cast<int64_t>(aChunkIdx)) {
|
|
// This is not a chunk that we're waiting for
|
|
LOG(
|
|
("CacheFileInputStream::OnChunkAvailable() - Notification is for a "
|
|
"different chunk. [this=%p, listeningForChunk=%" PRId64 "]",
|
|
this, mListeningForChunk));
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
MOZ_ASSERT(!mChunk);
|
|
MOZ_ASSERT(!mWaitingForUpdate);
|
|
MOZ_ASSERT(!mInReadSegments);
|
|
mListeningForChunk = -1;
|
|
|
|
if (mClosed) {
|
|
MOZ_ASSERT(!mCallback);
|
|
|
|
LOG(
|
|
("CacheFileInputStream::OnChunkAvailable() - Stream is closed, "
|
|
"ignoring notification. [this=%p]",
|
|
this));
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
if (NS_SUCCEEDED(aResult)) {
|
|
mChunk = aChunk;
|
|
} else if (aResult != NS_ERROR_NOT_AVAILABLE) {
|
|
// Close the stream with error. The consumer will receive this error later
|
|
// in Read(), Available() etc. We need to handle NS_ERROR_NOT_AVAILABLE
|
|
// differently since it is returned when the requested chunk is not
|
|
// available and there is no writer that could create it, i.e. it means that
|
|
// we've reached the end of the file.
|
|
CloseWithStatusLocked(aResult);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
MaybeNotifyListener();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult CacheFileInputStream::OnChunkUpdated(CacheFileChunk* aChunk) {
|
|
CacheFileAutoLock lock(mFile);
|
|
|
|
LOG(("CacheFileInputStream::OnChunkUpdated() [this=%p, idx=%d]", this,
|
|
aChunk->Index()));
|
|
|
|
if (!mWaitingForUpdate) {
|
|
LOG(
|
|
("CacheFileInputStream::OnChunkUpdated() - Ignoring notification since "
|
|
"mWaitingforUpdate == false. [this=%p]",
|
|
this));
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
mWaitingForUpdate = false;
|
|
|
|
MOZ_ASSERT(mChunk == aChunk);
|
|
|
|
MaybeNotifyListener();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void CacheFileInputStream::ReleaseChunk() {
|
|
mFile->AssertOwnsLock();
|
|
|
|
LOG(("CacheFileInputStream::ReleaseChunk() [this=%p, idx=%d]", this,
|
|
mChunk->Index()));
|
|
|
|
MOZ_ASSERT(!mInReadSegments);
|
|
|
|
if (mWaitingForUpdate) {
|
|
LOG(
|
|
("CacheFileInputStream::ReleaseChunk() - Canceling waiting for update. "
|
|
"[this=%p]",
|
|
this));
|
|
|
|
mChunk->CancelWait(this);
|
|
mWaitingForUpdate = false;
|
|
}
|
|
|
|
mFile->ReleaseOutsideLock(std::move(mChunk));
|
|
}
|
|
|
|
void CacheFileInputStream::EnsureCorrectChunk(bool aReleaseOnly) {
|
|
mFile->AssertOwnsLock();
|
|
|
|
LOG(("CacheFileInputStream::EnsureCorrectChunk() [this=%p, releaseOnly=%d]",
|
|
this, aReleaseOnly));
|
|
|
|
nsresult rv;
|
|
|
|
uint32_t chunkIdx = mPos / kChunkSize;
|
|
|
|
if (mInReadSegments) {
|
|
// We must have correct chunk
|
|
MOZ_ASSERT(mChunk);
|
|
MOZ_ASSERT(mChunk->Index() == chunkIdx);
|
|
return;
|
|
}
|
|
|
|
if (mChunk) {
|
|
if (mChunk->Index() == chunkIdx) {
|
|
// we have a correct chunk
|
|
LOG(
|
|
("CacheFileInputStream::EnsureCorrectChunk() - Have correct chunk "
|
|
"[this=%p, idx=%d]",
|
|
this, chunkIdx));
|
|
|
|
return;
|
|
}
|
|
ReleaseChunk();
|
|
}
|
|
|
|
MOZ_ASSERT(!mWaitingForUpdate);
|
|
|
|
if (aReleaseOnly) return;
|
|
|
|
if (mListeningForChunk == static_cast<int64_t>(chunkIdx)) {
|
|
// We're already waiting for this chunk
|
|
LOG(
|
|
("CacheFileInputStream::EnsureCorrectChunk() - Already listening for "
|
|
"chunk %" PRId64 " [this=%p]",
|
|
mListeningForChunk, this));
|
|
|
|
return;
|
|
}
|
|
|
|
rv = mFile->GetChunkLocked(chunkIdx, CacheFile::READER, this,
|
|
getter_AddRefs(mChunk));
|
|
if (NS_FAILED(rv)) {
|
|
LOG(
|
|
("CacheFileInputStream::EnsureCorrectChunk() - GetChunkLocked failed. "
|
|
"[this=%p, idx=%d, rv=0x%08" PRIx32 "]",
|
|
this, chunkIdx, static_cast<uint32_t>(rv)));
|
|
if (rv != NS_ERROR_NOT_AVAILABLE) {
|
|
// Close the stream with error. The consumer will receive this error later
|
|
// in Read(), Available() etc. We need to handle NS_ERROR_NOT_AVAILABLE
|
|
// differently since it is returned when the requested chunk is not
|
|
// available and there is no writer that could create it, i.e. it means
|
|
// that we've reached the end of the file.
|
|
CloseWithStatusLocked(rv);
|
|
|
|
return;
|
|
}
|
|
} else if (!mChunk) {
|
|
mListeningForChunk = static_cast<int64_t>(chunkIdx);
|
|
}
|
|
|
|
MaybeNotifyListener();
|
|
}
|
|
|
|
int64_t CacheFileInputStream::CanRead(CacheFileChunkReadHandle* aHandle) {
|
|
mFile->AssertOwnsLock();
|
|
|
|
MOZ_ASSERT(mChunk);
|
|
MOZ_ASSERT(mPos / kChunkSize == mChunk->Index());
|
|
|
|
int64_t retval = aHandle->Offset() + aHandle->DataSize();
|
|
|
|
if (!mAlternativeData && mFile->mAltDataOffset != -1 &&
|
|
mFile->mAltDataOffset < retval) {
|
|
retval = mFile->mAltDataOffset;
|
|
}
|
|
|
|
retval -= mPos;
|
|
if (retval <= 0 && NS_FAILED(mChunk->GetStatus())) {
|
|
CloseWithStatusLocked(mChunk->GetStatus());
|
|
}
|
|
|
|
LOG(("CacheFileInputStream::CanRead() [this=%p, canRead=%" PRId64 "]", this,
|
|
retval));
|
|
|
|
return retval;
|
|
}
|
|
|
|
void CacheFileInputStream::NotifyListener() {
|
|
mFile->AssertOwnsLock();
|
|
|
|
LOG(("CacheFileInputStream::NotifyListener() [this=%p]", this));
|
|
|
|
MOZ_ASSERT(mCallback);
|
|
MOZ_ASSERT(!mInReadSegments);
|
|
|
|
if (!mCallbackTarget) {
|
|
mCallbackTarget = CacheFileIOManager::IOTarget();
|
|
if (!mCallbackTarget) {
|
|
LOG(
|
|
("CacheFileInputStream::NotifyListener() - Cannot get Cache I/O "
|
|
"thread! Using main thread for callback."));
|
|
mCallbackTarget = GetMainThreadEventTarget();
|
|
}
|
|
}
|
|
|
|
nsCOMPtr<nsIInputStreamCallback> asyncCallback = NS_NewInputStreamReadyEvent(
|
|
"CacheFileInputStream::NotifyListener", mCallback, mCallbackTarget);
|
|
|
|
mCallback = nullptr;
|
|
mCallbackTarget = nullptr;
|
|
|
|
asyncCallback->OnInputStreamReady(this);
|
|
}
|
|
|
|
void CacheFileInputStream::MaybeNotifyListener() {
|
|
mFile->AssertOwnsLock();
|
|
|
|
LOG(
|
|
("CacheFileInputStream::MaybeNotifyListener() [this=%p, mCallback=%p, "
|
|
"mClosed=%d, mStatus=0x%08" PRIx32
|
|
", mChunk=%p, mListeningForChunk=%" PRId64 ", "
|
|
"mWaitingForUpdate=%d]",
|
|
this, mCallback.get(), mClosed, static_cast<uint32_t>(mStatus),
|
|
mChunk.get(), mListeningForChunk, mWaitingForUpdate));
|
|
|
|
MOZ_ASSERT(!mInReadSegments);
|
|
|
|
if (!mCallback) return;
|
|
|
|
if (mClosed || NS_FAILED(mStatus)) {
|
|
NotifyListener();
|
|
return;
|
|
}
|
|
|
|
if (!mChunk) {
|
|
if (mListeningForChunk == -1) {
|
|
// EOF, should we notify even if mCallbackFlags == WAIT_CLOSURE_ONLY ??
|
|
NotifyListener();
|
|
}
|
|
return;
|
|
}
|
|
|
|
MOZ_ASSERT(mPos / kChunkSize == mChunk->Index());
|
|
|
|
if (mWaitingForUpdate) return;
|
|
|
|
CacheFileChunkReadHandle hnd = mChunk->GetReadHandle();
|
|
int64_t canRead = CanRead(&hnd);
|
|
if (NS_FAILED(mStatus)) {
|
|
// CanRead() called CloseWithStatusLocked() which called
|
|
// MaybeNotifyListener() so the listener was already notified. Stop here.
|
|
MOZ_ASSERT(!mCallback);
|
|
return;
|
|
}
|
|
|
|
if (canRead > 0) {
|
|
if (!(mCallbackFlags & WAIT_CLOSURE_ONLY)) NotifyListener();
|
|
} else if (canRead == 0) {
|
|
if (!mFile->OutputStreamExists(mAlternativeData)) {
|
|
// EOF
|
|
NotifyListener();
|
|
} else {
|
|
mChunk->WaitForUpdate(this);
|
|
mWaitingForUpdate = true;
|
|
}
|
|
} else {
|
|
// Output have set EOF before mPos?
|
|
MOZ_ASSERT(false, "SetEOF is currenty not implemented?!");
|
|
NotifyListener();
|
|
}
|
|
}
|
|
|
|
// Memory reporting
|
|
|
|
size_t CacheFileInputStream::SizeOfIncludingThis(
|
|
mozilla::MallocSizeOf mallocSizeOf) const {
|
|
// Everything the stream keeps a reference to is already reported somewhere
|
|
// else. mFile reports itself. mChunk reported as part of CacheFile. mCallback
|
|
// is usually CacheFile or a class that is reported elsewhere.
|
|
return mallocSizeOf(this);
|
|
}
|
|
|
|
} // namespace mozilla::net
|