forked from mirrors/gecko-dev
3b40268cc1
This is semantically similar to the existing available() method, however will not block, and doesn't need to do the work to actually determine the number of available bytes. As part of this patch, I also fixed one available() implementation which was incorrectly throwing NS_BASE_STREAM_WOULD_BLOCK. Differential Revision: https://phabricator.services.mozilla.com/D170697
734 lines
19 KiB
C++
734 lines
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::StreamStatus() {
|
|
CacheFileAutoLock lock(mFile);
|
|
|
|
if (mClosed) {
|
|
LOG(
|
|
("CacheFileInputStream::StreamStatus() - Stream is closed. [this=%p, "
|
|
"status=0x%08" PRIx32 "]",
|
|
this, static_cast<uint32_t>(mStatus)));
|
|
return NS_FAILED(mStatus) ? mStatus : NS_BASE_STREAM_CLOSED;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
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 = GetMainThreadSerialEventTarget();
|
|
}
|
|
}
|
|
|
|
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
|