Bommels05/Mozilla
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Back out dougt's channel changes

Browse Source 
git-svn-id: svn://10.0.0.236/trunk@86793 18797224-902f-48f8-a5cc-f745e15eee43
This commit is contained in:
disttsc%bart.nl
2001-02-12 03:14:23 +00:00
parent 5d2ade1fb4
commit 03f69c5003
275 changed files with 7847 additions and 5710 deletions
Download Patch File Download Diff File Expand all files Collapse all files

346
mozilla/netwerk/cache/memcache/nsMemCacheChannel.cpp vendored
View File

@@ -33,13 +33,10 @@
static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
static NS_DEFINE_CID(kEventQueueService, NS_EVENTQUEUESERVICE_CID);
NS_IMPL_THREADSAFE_ISUPPORTS3(nsMemCacheTransport,
nsITransport,
nsITransportRequest,
nsIRequest)
NS_IMPL_THREADSAFE_ISUPPORTS1(nsMemCacheChannel, nsIChannel)
void
nsMemCacheTransport::NotifyStorageInUse(PRInt32 aBytesUsed)
nsMemCacheChannel::NotifyStorageInUse(PRInt32 aBytesUsed)
{
mRecord->mCache->mOccupancy += aBytesUsed;
}
@@ -53,9 +50,9 @@ class AsyncReadStreamAdaptor : public nsIInputStream,
public nsIStreamListener
{
public:
AsyncReadStreamAdaptor(nsMemCacheTransport* aChannel, nsIInputStream *aSyncStream):
AsyncReadStreamAdaptor(nsMemCacheChannel* aChannel, nsIInputStream *aSyncStream):
mSyncStream(aSyncStream), mDataAvailCursor(0),
mRemaining((PRUint32)-1), mAvailable(0), mChannel(aChannel), mAbortStatus(NS_OK), mSuspended(PR_FALSE)
mRemaining(-1), mAvailable(0), mChannel(aChannel), mAbortStatus(NS_OK), mSuspended(PR_FALSE)
{
NS_INIT_REFCNT();
NS_ADDREF(mChannel);
@@ -78,10 +75,8 @@ public:
Cancel(nsresult status) {
if (NS_SUCCEEDED(mAbortStatus)) {
mAbortStatus = status;
if (!mChannel->mCurrentReadRequest)
return NS_ERROR_FAILURE;
return mEventQueueStreamListener ?
mEventQueueStreamListener->OnStopRequest(mChannel->mCurrentReadRequest, mContext, status, nsnull):
mEventQueueStreamListener->OnStopRequest(mChannel, mContext, status, nsnull):
status;
} else {
// Cancel has already been called... Do not fire another OnStopRequest!
@@ -109,14 +104,11 @@ public:
// event to the downstream listener and causes another OnDataAvailable()
// event to be enqueued.
NS_IMETHOD
OnDataAvailable(nsIRequest* request, nsISupports *aContext,
OnDataAvailable(nsIChannel *channel, nsISupports *aContext,
nsIInputStream *inStr, PRUint32 sourceOffset, PRUint32 count) {
nsresult rv;
if (!mChannel->mCurrentReadRequest)
return NS_ERROR_FAILURE;
rv = mDownstreamListener->OnDataAvailable(mChannel->mCurrentReadRequest, aContext, inStr, sourceOffset, count);
rv = mDownstreamListener->OnDataAvailable(mChannel, aContext, inStr, sourceOffset, count);
if (NS_FAILED(rv)) {
Cancel(rv);
return rv;
@@ -132,15 +124,13 @@ public:
}
NS_IMETHOD
OnStartRequest(nsIRequest* request, nsISupports *aContext) {
OnStartRequest(nsIChannel *channel, nsISupports *aContext) {
nsresult rv = NS_OK;
NS_ASSERTION(mDownstreamListener, "no downstream listener");
if (mDownstreamListener) {
if (!mChannel->mCurrentReadRequest)
return NS_ERROR_FAILURE;
rv = mDownstreamListener->OnStartRequest(mChannel->mCurrentReadRequest, aContext);
rv = mDownstreamListener->OnStartRequest(mChannel, aContext);
}
if (NS_FAILED(rv))
@@ -149,7 +139,7 @@ public:
}
NS_IMETHOD
OnStopRequest(nsIRequest* request, nsISupports *aContext,
OnStopRequest(nsIChannel *channel, nsISupports *aContext,
nsresult aStatus, const PRUnichar* aStatusArg) {
nsresult rv = NS_OK;
@@ -157,9 +147,7 @@ public:
NS_ASSERTION(mDownstreamListener, "no downstream listener");
if (mDownstreamListener) {
if (!mChannel->mCurrentReadRequest)
return NS_ERROR_FAILURE;
rv = mDownstreamListener->OnStopRequest(mChannel->mCurrentReadRequest, aContext, aStatus, aStatusArg);
rv = mDownstreamListener->OnStopRequest(mChannel, aContext, aStatus, aStatusArg);
mDownstreamListener = 0;
}
// Tricky: causes this instance to be free'ed because mEventQueueStreamListener
@@ -232,9 +220,7 @@ public:
}
nsresult
AsyncRead(nsIStreamListener* aListener, nsISupports* aContext,
PRUint32 transferOffset, PRUint32 transferCount,
PRUint32 flags, nsIRequest **_retval) {
AsyncRead(nsIStreamListener* aListener, nsISupports* aContext) {
nsresult rv;
nsIEventQueue *eventQ;
@@ -256,10 +242,7 @@ public:
NS_RELEASE(eventQ);
if (NS_FAILED(rv)) return rv;
if (!mChannel->mCurrentReadRequest)
return NS_ERROR_FAILURE;
rv = mEventQueueStreamListener->OnStartRequest(mChannel->mCurrentReadRequest, aContext);
rv = mEventQueueStreamListener->OnStartRequest(mChannel, aContext);
if (NS_FAILED(rv)) return rv;
return NextListenerEvent();
@@ -269,12 +252,8 @@ protected:
nsresult
Fail(void) {
if (!mChannel->mCurrentReadRequest)
return NS_ERROR_FAILURE;
mAbortStatus = NS_BINDING_ABORTED;
return mEventQueueStreamListener->OnStopRequest(mChannel->mCurrentReadRequest, mContext,
NS_BINDING_FAILED, nsnull);
return mEventQueueStreamListener->OnStopRequest(mChannel, mContext, NS_BINDING_FAILED, nsnull);
}
// If more data remains in the source stream that the downstream consumer
@@ -288,19 +267,16 @@ protected:
available -= mAvailable;
available = PR_MIN(available, mRemaining);
if (!mChannel->mCurrentReadRequest)
return NS_ERROR_FAILURE;
if (available) {
PRUint32 size = PR_MIN(available, MEM_CACHE_SEGMENT_SIZE);
rv = mEventQueueStreamListener->OnDataAvailable(mChannel->mCurrentReadRequest, mContext, this,
rv = mEventQueueStreamListener->OnDataAvailable(mChannel, mContext, this,
mDataAvailCursor, size);
mDataAvailCursor += size;
mRemaining -= size;
mAvailable += size;
return rv;
} else {
rv = mEventQueueStreamListener->OnStopRequest(mChannel->mCurrentReadRequest, mContext, NS_OK, nsnull);
rv = mEventQueueStreamListener->OnStopRequest(mChannel, mContext, NS_OK, nsnull);
AsyncReadStreamAdaptor* thisAlias = this;
NS_RELEASE(thisAlias);
return rv;
@@ -317,7 +293,7 @@ private:
PRUint32 mRemaining; // Size of AsyncRead request less bytes for
// consumer OnDataAvailable's that were fired
PRUint32 mAvailable; // Number of bytes for which OnDataAvailable fired
nsMemCacheTransport* mChannel; // Associated memory cache channel, strong link
nsMemCacheChannel* mChannel; // Associated memory cache channel, strong link
// but can not use nsCOMPtr
nsresult mAbortStatus; // Abort() has been called
PRBool mSuspended; // Suspend() has been called
@@ -330,7 +306,7 @@ NS_IMPL_ISUPPORTS3(AsyncReadStreamAdaptor, nsIInputStream,
// overall occupancy as new data flows into the cache entry.
class MemCacheWriteStreamWrapper : public nsIOutputStream {
public:
MemCacheWriteStreamWrapper(nsMemCacheTransport* aChannel, nsIOutputStream *aBaseStream):
MemCacheWriteStreamWrapper(nsMemCacheChannel* aChannel, nsIOutputStream *aBaseStream):
mBaseStream(aBaseStream), mChannel(aChannel)
{
NS_INIT_REFCNT();
@@ -340,7 +316,7 @@ public:
virtual ~MemCacheWriteStreamWrapper() { NS_RELEASE(mChannel); };
static nsresult
Create(nsMemCacheTransport* aChannel, nsIOutputStream *aBaseStream, nsIOutputStream* *aWrapper) {
Create(nsMemCacheChannel* aChannel, nsIOutputStream *aBaseStream, nsIOutputStream* *aWrapper) {
MemCacheWriteStreamWrapper *wrapper =
new MemCacheWriteStreamWrapper(aChannel, aBaseStream);
if (!wrapper) return NS_ERROR_OUT_OF_MEMORY;
@@ -403,32 +379,33 @@ public:
private:
nsCOMPtr<nsIOutputStream> mBaseStream;
nsMemCacheTransport* mChannel;
nsMemCacheChannel* mChannel;
};
NS_IMPL_THREADSAFE_ISUPPORTS1(MemCacheWriteStreamWrapper, nsIOutputStream)
nsMemCacheTransport::nsMemCacheTransport(nsMemCacheRecord *aRecord, nsILoadGroup *aLoadGroup)
: mRecord(aRecord), mStartOffset(0), mStatus(NS_OK)
nsMemCacheChannel::nsMemCacheChannel(nsMemCacheRecord *aRecord, nsILoadGroup *aLoadGroup)
: mRecord(aRecord), mStartOffset(0), mStatus(NS_OK),
mLoadAttributes(nsIChannel::LOAD_NORMAL)
{
NS_INIT_REFCNT();
mRecord->mNumTransports++;
mRecord->mNumChannels++;
}
nsMemCacheTransport::~nsMemCacheTransport()
nsMemCacheChannel::~nsMemCacheChannel()
{
mRecord->mNumTransports--;
mRecord->mNumChannels--;
}
NS_IMETHODIMP
nsMemCacheTransport::GetName(PRUnichar* *result)
nsMemCacheChannel::GetName(PRUnichar* *result)
{
NS_NOTREACHED("nsMemCacheTransport::GetName");
NS_NOTREACHED("nsMemCacheChannel::GetName");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheTransport::IsPending(PRBool* aIsPending)
nsMemCacheChannel::IsPending(PRBool* aIsPending)
{
*aIsPending = PR_FALSE;
if (!mAsyncReadStream)
@@ -437,14 +414,14 @@ nsMemCacheTransport::IsPending(PRBool* aIsPending)
}
NS_IMETHODIMP
nsMemCacheTransport::GetStatus(nsresult *status)
nsMemCacheChannel::GetStatus(nsresult *status)
{
*status = mStatus;
return NS_OK;
}
NS_IMETHODIMP
nsMemCacheTransport::Cancel(nsresult status)
nsMemCacheChannel::Cancel(nsresult status)
{
mStatus = status;
if (!mAsyncReadStream)
@@ -453,7 +430,7 @@ nsMemCacheTransport::Cancel(nsresult status)
}
NS_IMETHODIMP
nsMemCacheTransport::Suspend(void)
nsMemCacheChannel::Suspend(void)
{
if (!mAsyncReadStream)
return NS_ERROR_FAILURE;
@@ -461,60 +438,54 @@ nsMemCacheTransport::Suspend(void)
}
NS_IMETHODIMP
nsMemCacheTransport::Resume(void)
nsMemCacheChannel::Resume(void)
{
if (!mAsyncReadStream)
return NS_ERROR_FAILURE;
return mAsyncReadStream->Resume();
}
#if 0
NS_IMETHODIMP
nsMemCacheTransport::GetOriginalURI(nsIURI* *aURI)
nsMemCacheChannel::GetOriginalURI(nsIURI* *aURI)
{
// Not required
NS_NOTREACHED("nsMemCacheTransport::GetOriginalURI");
NS_NOTREACHED("nsMemCacheChannel::GetOriginalURI");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheTransport::SetOriginalURI(nsIURI* aURI)
nsMemCacheChannel::SetOriginalURI(nsIURI* aURI)
{
// Not required
NS_NOTREACHED("nsMemCacheTransport::SetOriginalURI");
NS_NOTREACHED("nsMemCacheChannel::SetOriginalURI");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheTransport::GetURI(nsIURI* *aURI)
nsMemCacheChannel::GetURI(nsIURI* *aURI)
{
// Not required to be implemented, since it is implemented by cache manager
NS_NOTREACHED("nsMemCacheTransport::GetURI");
NS_NOTREACHED("nsMemCacheChannel::GetURI");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheTransport::SetURI(nsIURI* aURI)
nsMemCacheChannel::SetURI(nsIURI* aURI)
{
// Not required to be implemented, since it is implemented by cache manager
NS_NOTREACHED("nsMemCacheTransport::SetURI");
NS_NOTREACHED("nsMemCacheChannel::SetURI");
return NS_ERROR_NOT_IMPLEMENTED;
}
#endif
NS_IMETHODIMP
nsMemCacheTransport::OpenInputStream(PRUint32 transferOffset,
PRUint32 transferCount,
PRUint32 transferFlags,
nsIInputStream* *aResult)
nsMemCacheChannel::OpenInputStream(nsIInputStream* *aResult)
{
nsresult rv;
NS_ENSURE_ARG(aResult);
if (mInputStream)
return NS_ERROR_NOT_AVAILABLE;
rv = mRecord->mStorageStream->NewInputStream(transferOffset, getter_AddRefs(mInputStream));
rv = mRecord->mStorageStream->NewInputStream(mStartOffset, getter_AddRefs(mInputStream));
if (NS_FAILED(rv)) return rv;
*aResult = mInputStream;
NS_ADDREF(*aResult);
@@ -522,10 +493,7 @@ nsMemCacheTransport::OpenInputStream(PRUint32 transferOffset,
}
NS_IMETHODIMP
nsMemCacheTransport::OpenOutputStream(PRUint32 transferOffset,
PRUint32 transferCount,
PRUint32 transferFlags,
nsIOutputStream* *aResult)
nsMemCacheChannel::OpenOutputStream(nsIOutputStream* *aResult)
{
nsresult rv;
NS_ENSURE_ARG(aResult);
@@ -534,24 +502,19 @@ nsMemCacheTransport::OpenOutputStream(PRUint32 transferOffset,
PRUint32 oldLength;
mRecord->mStorageStream->GetLength(&oldLength);
rv = mRecord->mStorageStream->GetOutputStream(transferOffset, getter_AddRefs(outputStream));
rv = mRecord->mStorageStream->GetOutputStream(mStartOffset, getter_AddRefs(outputStream));
if (NS_FAILED(rv)) return rv;
if (transferOffset < oldLength)
NotifyStorageInUse(transferOffset - oldLength);
if (mStartOffset < oldLength)
NotifyStorageInUse(mStartOffset - oldLength);
return MemCacheWriteStreamWrapper::Create(this, outputStream, aResult);
}
NS_IMETHODIMP
nsMemCacheTransport::AsyncRead(nsIStreamListener *aListener,
nsISupports *aContext,
PRUint32 transferOffset,
PRUint32 transferCount,
PRUint32 transferFlags,
nsIRequest **_retval)
nsMemCacheChannel::AsyncRead(nsIStreamListener *aListener, nsISupports *aContext)
{
nsCOMPtr<nsIInputStream> inputStream;
nsresult rv = OpenInputStream(0, 0, 0, getter_AddRefs(inputStream));
nsresult rv = OpenInputStream(getter_AddRefs(inputStream));
if (NS_FAILED(rv)) return rv;
AsyncReadStreamAdaptor *asyncReadStreamAdaptor;
@@ -561,56 +524,197 @@ nsMemCacheTransport::AsyncRead(nsIStreamListener *aListener,
NS_ADDREF(asyncReadStreamAdaptor);
mAsyncReadStream = asyncReadStreamAdaptor;
rv = asyncReadStreamAdaptor->AsyncRead(aListener, aContext,
transferOffset,
transferCount,
transferFlags,
getter_AddRefs(mCurrentReadRequest));
rv = asyncReadStreamAdaptor->AsyncRead(aListener, aContext);
if (NS_FAILED(rv)) {
mAsyncReadStream = nsnull;
NS_RELEASE(asyncReadStreamAdaptor);
}
NS_ADDREF(*_retval=this);
return rv;
}
NS_IMETHODIMP
nsMemCacheTransport::AsyncWrite(nsIStreamProvider *provider,
nsISupports *ctxt,
PRUint32 transferOffset,
PRUint32 transferCount,
PRUint32 transferFlags,
nsIRequest **_retval)
nsMemCacheChannel::AsyncWrite(nsIStreamProvider *provider, nsISupports *ctxt)
{
// Not required to be implemented
NS_NOTREACHED("nsMemCacheTransport::AsyncWrite");
NS_NOTREACHED("nsMemCacheChannel::AsyncWrite");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::GetTransferOffset(PRUint32 *aTransferOffset)
{
*aTransferOffset = mStartOffset;
return NS_OK;
}
NS_IMETHODIMP
nsMemCacheChannel::SetTransferOffset(PRUint32 aTransferOffset)
{
mStartOffset = aTransferOffset;
return NS_OK;
}
NS_IMETHODIMP
nsMemCacheChannel::GetTransferCount(PRInt32 *aTransferCount)
{
NS_NOTREACHED("nsMemCacheChannel::GetTransferCount");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::SetTransferCount(PRInt32 aTransferCount)
{
NS_NOTREACHED("nsMemCacheChannel::SetTransferCount");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::GetBufferSegmentSize(PRUint32 *aBufferSegmentSize)
{
NS_NOTREACHED("nsMemCacheChannel::GetBufferSegmentSize");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::SetBufferSegmentSize(PRUint32 aBufferSegmentSize)
{
NS_NOTREACHED("nsMemCacheChannel::SetBufferSegmentSize");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::GetBufferMaxSize(PRUint32 *aBufferMaxSize)
{
NS_NOTREACHED("nsMemCacheChannel::GetBufferMaxSize");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::SetBufferMaxSize(PRUint32 aBufferMaxSize)
{
NS_NOTREACHED("nsMemCacheChannel::SetBufferMaxSize");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::GetLocalFile(nsIFile* *file)
{
*file = nsnull;
return NS_OK;
}
NS_IMETHODIMP
nsMemCacheChannel::GetPipeliningAllowed(PRBool *aPipeliningAllowed)
{
*aPipeliningAllowed = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP
nsMemCacheChannel::SetPipeliningAllowed(PRBool aPipeliningAllowed)
{
NS_NOTREACHED("SetPipeliningAllowed");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::SetContentLength(PRInt32 aContentLength)
{
return NS_OK;
}
NS_IMETHODIMP
nsMemCacheChannel::GetLoadAttributes(nsLoadFlags *aLoadAttributes)
{
*aLoadAttributes = mLoadAttributes;
return NS_OK;
}
NS_IMETHODIMP
nsMemCacheChannel::SetLoadAttributes(nsLoadFlags aLoadAttributes)
{
mLoadAttributes = aLoadAttributes;
return NS_OK;
}
NS_IMETHODIMP
nsMemCacheChannel::GetContentType(char* *aContentType)
{
// Not required to be implemented, since it is implemented by cache manager
NS_NOTREACHED("nsMemCacheChannel::GetContentType");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::SetContentType(const char *aContentType)
{
// Not required to be implemented, since it is implemented by cache manager
NS_NOTREACHED("nsMemCacheChannel::SetContentType");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::GetContentLength(PRInt32 *aContentLength)
{
PRUint32 cl = 0;
mRecord->GetStoredContentLength(&cl);
*aContentLength = (PRInt32) cl;
return NS_OK;
}
NS_IMETHODIMP
nsMemCacheChannel::GetOwner(nsISupports* *aOwner)
{
*aOwner = mOwner.get();
NS_IF_ADDREF(*aOwner);
return NS_OK;
}
NS_IMETHODIMP
nsMemCacheChannel::SetOwner(nsISupports* aOwner)
{
// Not required to be implemented, since it is implemented by cache manager
mOwner = aOwner;
return NS_OK;
}
NS_IMETHODIMP
nsMemCacheChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
{
// Not required to be implemented, since it is implemented by cache manager
NS_NOTREACHED("nsMemCacheChannel::GetLoadGroup");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::SetLoadGroup(nsILoadGroup* aLoadGroup)
{
// Not required to be implemented, since it is implemented by cache manager
NS_NOTREACHED("nsMemCacheChannel::SetLoadGroup");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::GetNotificationCallbacks(nsIInterfaceRequestor* *aNotificationCallbacks)
{
// Not required to be implemented, since it is implemented by cache manager
NS_NOTREACHED("nsMemCacheChannel::GetNotificationCallbacks");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aNotificationCallbacks)
{
// Not required to be implemented, since it is implemented by cache manager
NS_NOTREACHED("nsMemCacheChannel::SetNotificationCallbacks");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheTransport::GetSecurityInfo(nsISupports * *aSecurityInfo)
nsMemCacheChannel::GetSecurityInfo(nsISupports * *aSecurityInfo)
{
*aSecurityInfo = nsnull;
return NS_OK;
}
NS_IMETHODIMP
nsMemCacheTransport::GetProgressEventSink(nsIProgressEventSink **aResult)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheTransport::SetProgressEventSink(nsIProgressEventSink *aProgress)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsMemCacheTransport::GetTransport(nsITransport **result)
{
NS_ENSURE_ARG_POINTER(result);
NS_ADDREF(*result = this);
return NS_OK;
}