corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revising nsIChannel to allow for overlapped i/o. This consists of three parts:

Browse Source 
1. Factoring nsIChannel into a protocol specific part, the nsIChannel, and a socket specific, the nsITransport.
2. Derive the nsIChannel from a nsIRequest.
2. Changes the notification system from necko and the URILoader to pass the nsIRequest interface instead of nsIChannel interface.

This goal stems from wanting to be able to have active AsyncRead and AsyncWrite operations on nsSocketTransport.
This is desired because it would greatly simplify the task of maintaining persistent/reusable socket connections
for FTP, HTTP, and Imap (and potentially other protocols).  The problem with the existing nsIChannel interface is
that it does not allow one to selectively suspend just one of the read or write operations while keeping the other active.

The full details of the change on written up in the netlib newsgroup.

r=darin@netscape.com
sr=rpotts@netscape.com
This commit is contained in:
dougt@netscape.com
2001-02-10 00:16:26 +00:00
parent b762af79b0
commit a70fce6f87
218 changed files with 5596 additions and 6769 deletions
Download Patch File Download Diff File Expand all files Collapse all files

176
chrome/src/nsChromeProtocolHandler.cpp
View File

@@ -116,27 +116,25 @@ public:
NS_DECL_ISUPPORTS
// nsIRequest
NS_IMETHOD GetName(PRUnichar* *result) {
NS_NOTREACHED("nsCachedChromeChannel::GetName");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHOD GetName(PRUnichar* *result) { return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD IsPending(PRBool *_retval) { *_retval = PR_TRUE; return NS_OK; }
NS_IMETHOD GetStatus(nsresult *status) { *status = mStatus; return NS_OK; }
NS_IMETHOD Cancel(nsresult status) { mStatus = status; return NS_OK; }
NS_IMETHOD Suspend(void) { return NS_OK; }
NS_IMETHOD Resume(void) { return NS_OK; }
// nsIChannel
// nsIChannel
NS_DECL_NSICHANNEL
};
#ifdef PR_LOGGING
PRLogModuleInfo* nsCachedChromeChannel::gLog;
#endif
NS_IMPL_ADDREF(nsCachedChromeChannel);
NS_IMPL_RELEASE(nsCachedChromeChannel);
NS_IMPL_QUERY_INTERFACE2(nsCachedChromeChannel, nsIRequest, nsIChannel);
NS_IMPL_ISUPPORTS2(nsCachedChromeChannel,
nsIChannel,
nsIRequest);
nsresult
nsCachedChromeChannel::Create(nsIURI* aURI, nsIChannel** aResult)
@@ -211,7 +209,7 @@ nsCachedChromeChannel::SetURI(nsIURI* aURI)
}
NS_IMETHODIMP
nsCachedChromeChannel::OpenInputStream(nsIInputStream **_retval)
nsCachedChromeChannel::Open(nsIInputStream **_retval)
{
// NS_NOTREACHED("don't do that");
*_retval = nsnull;
@@ -219,15 +217,7 @@ nsCachedChromeChannel::OpenInputStream(nsIInputStream **_retval)
}
NS_IMETHODIMP
nsCachedChromeChannel::OpenOutputStream(nsIOutputStream **_retval)
{
NS_NOTREACHED("don't do that");
*_retval = nsnull;
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsCachedChromeChannel::AsyncRead(nsIStreamListener *listener, nsISupports *ctxt)
nsCachedChromeChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt)
{
if (listener) {
nsresult rv;
@@ -237,7 +227,7 @@ nsCachedChromeChannel::AsyncRead(nsIStreamListener *listener, nsISupports *ctxt)
("nsCachedChromeChannel[%p]: adding self to load group %p",
this, mLoadGroup.get()));
rv = mLoadGroup->AddChannel(this, nsnull);
rv = mLoadGroup->AddRequest(this, nsnull);
if (NS_FAILED(rv)) return rv;
}
@@ -257,7 +247,7 @@ nsCachedChromeChannel::AsyncRead(nsIStreamListener *listener, nsISupports *ctxt)
("nsCachedChromeChannel[%p]: removing self from load group %p",
this, mLoadGroup.get()));
(void) mLoadGroup->RemoveChannel(this, nsnull, nsnull, nsnull);
(void) mLoadGroup->RemoveRequest(this, nsnull, nsnull, nsnull);
}
return rv;
@@ -271,10 +261,9 @@ nsCachedChromeChannel::AsyncRead(nsIStreamListener *listener, nsISupports *ctxt)
}
NS_IMETHODIMP
nsCachedChromeChannel::AsyncWrite(nsIStreamProvider *provider, nsISupports *ctxt)
nsCachedChromeChannel::GetSecurityInfo(nsISupports * *aSecurityInfo)
{
NS_NOTREACHED("don't do that");
return NS_ERROR_FAILURE;
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
@@ -291,113 +280,6 @@ nsCachedChromeChannel::SetLoadAttributes(nsLoadFlags aLoadAttributes)
return NS_OK;
}
NS_IMETHODIMP
nsCachedChromeChannel::GetContentType(char * *aContentType)
{
*aContentType = nsXPIDLCString::Copy("text/cached-xul");
return *aContentType ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
NS_IMETHODIMP
nsCachedChromeChannel::SetContentType(const char *aContentType)
{
// Do not allow the content-type to be changed.
NS_NOTREACHED("don't do that");
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsCachedChromeChannel::GetContentLength(PRInt32 *aContentLength)
{
NS_NOTREACHED("don't do that");
*aContentLength = 0;
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsCachedChromeChannel::SetContentLength(PRInt32 aContentLength)
{
NS_NOTREACHED("nsCachedChromeChannel::SetContentLength");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsCachedChromeChannel::GetTransferOffset(PRUint32 *aTransferOffset)
{
NS_NOTREACHED("nsCachedChromeChannel::GetTransferOffset");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsCachedChromeChannel::SetTransferOffset(PRUint32 aTransferOffset)
{
NS_NOTREACHED("nsCachedChromeChannel::SetTransferOffset");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsCachedChromeChannel::GetTransferCount(PRInt32 *aTransferCount)
{
NS_NOTREACHED("nsCachedChromeChannel::GetTransferCount");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsCachedChromeChannel::SetTransferCount(PRInt32 aTransferCount)
{
NS_NOTREACHED("nsCachedChromeChannel::SetTransferCount");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsCachedChromeChannel::GetBufferSegmentSize(PRUint32 *aBufferSegmentSize)
{
NS_NOTREACHED("nsCachedChromeChannel::GetBufferSegmentSize");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsCachedChromeChannel::SetBufferSegmentSize(PRUint32 aBufferSegmentSize)
{
NS_NOTREACHED("nsCachedChromeChannel::SetBufferSegmentSize");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsCachedChromeChannel::GetBufferMaxSize(PRUint32 *aBufferMaxSize)
{
NS_NOTREACHED("nsCachedChromeChannel::GetBufferMaxSize");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsCachedChromeChannel::SetBufferMaxSize(PRUint32 aBufferMaxSize)
{
NS_NOTREACHED("nsCachedChromeChannel::SetBufferMaxSize");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsCachedChromeChannel::GetLocalFile(nsIFile* *file)
{
*file = nsnull;
return NS_OK;
}
NS_IMETHODIMP
nsCachedChromeChannel::GetPipeliningAllowed(PRBool *aPipeliningAllowed)
{
*aPipeliningAllowed = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP
nsCachedChromeChannel::SetPipeliningAllowed(PRBool aPipeliningAllowed)
{
NS_NOTREACHED("SetPipeliningAllowed");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsCachedChromeChannel::GetOwner(nsISupports * *aOwner)
{
@@ -441,12 +323,34 @@ nsCachedChromeChannel::SetNotificationCallbacks(nsIInterfaceRequestor * aNotific
return NS_OK; // ignored
}
NS_IMETHODIMP
nsCachedChromeChannel::GetContentType(char * *aContentType)
{
*aContentType = nsXPIDLCString::Copy("text/cached-xul");
return *aContentType ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
NS_IMETHODIMP
nsCachedChromeChannel::GetSecurityInfo(nsISupports * *aSecurityInfo)
nsCachedChromeChannel::SetContentType(const char *aContentType)
{
*aSecurityInfo = nsnull;
return NS_OK;
// Do not allow the content-type to be changed.
NS_NOTREACHED("don't do that");
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsCachedChromeChannel::GetContentLength(PRInt32 *aContentLength)
{
NS_NOTREACHED("don't do that");
*aContentLength = 0;
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsCachedChromeChannel::SetContentLength(PRInt32 aContentLength)
{
NS_NOTREACHED("nsCachedChromeChannel::SetContentLength");
return NS_ERROR_NOT_IMPLEMENTED;
}
nsresult
@@ -523,12 +427,14 @@ nsCachedChromeChannel::HandleStopLoadEvent(PLEvent* aEvent)
// remove it from the load group.
LoadEvent* event = NS_REINTERPRET_CAST(LoadEvent*, aEvent);
nsCachedChromeChannel* channel = event->mChannel;
nsIRequest* request = NS_REINTERPRET_CAST(nsIRequest*, channel);
PR_LOG(gLog, PR_LOG_DEBUG,
("nsCachedChromeChannel[%p]: firing OnStopRequest for %p",
channel, channel->mListener.get()));
(void) channel->mListener->OnStopRequest(channel, channel->mContext,
(void) channel->mListener->OnStopRequest(request, channel->mContext,
channel->mStatus, nsnull);
if (channel->mLoadGroup) {
@@ -536,7 +442,7 @@ nsCachedChromeChannel::HandleStopLoadEvent(PLEvent* aEvent)
("nsCachedChromeChannel[%p]: removing self from load group %p",
channel, channel->mLoadGroup.get()));
(void) channel->mLoadGroup->RemoveChannel(channel, nsnull, nsnull, nsnull);
(void) channel->mLoadGroup->RemoveRequest(request, nsnull, nsnull, nsnull);
}
channel->mListener = nsnull;

2
content/base/src/nsSyncLoadService.cpp
View File

@@ -298,7 +298,7 @@ nsSyncLoader::LoadDocument(nsIURI* documentURI, nsIDOMDocument **_retval)
}
// Start reading from the channel
rv = channel->AsyncRead(listener, nsnull);
rv = channel->AsyncOpen(listener, nsnull);
if (NS_FAILED(rv)) {
if (modalEventQueue) {

8
content/html/document/src/nsHTMLContentSink.cpp
View File

@@ -4715,8 +4715,12 @@ HTMLContentSink::OnStreamComplete(nsIStreamLoader* aLoader,
nsCOMPtr<nsIHTTPChannel> httpChannel;
nsCOMPtr<nsIChannel> channel;
rv = aLoader->GetChannel(getter_AddRefs(channel));
NS_ASSERTION(channel, "StreamLoader's channel went away prematurely");
nsCOMPtr<nsIRequest> request;
rv = aLoader->GetRequest(getter_AddRefs(request));
NS_ASSERTION(request, "StreamLoader's request went away prematurely");
if (NS_FAILED(rv)) return rv;
channel = do_QueryInterface(request);
if (channel) {
httpChannel = do_QueryInterface(channel);

10
content/html/document/src/nsHTMLDocument.cpp
View File

@@ -585,7 +585,8 @@ nsHTMLDocument::StartDocumentLoad(const char* aCommand,
nsCOMPtr<nsIFile> file;
rv = fileChannel->GetFile(getter_AddRefs(file));
if (NS_FAILED(rv)) { return rv; }
if (NS_SUCCEEDED(rv))
{
// if we failed to get a last modification date, then we don't want to necessarily
// fail to create a document for this file. Just don't set the last modified date on it...
rv = file->GetLastModificationDate(&modDate);
@@ -603,16 +604,17 @@ nsHTMLDocument::StartDocumentLoad(const char* aCommand,
// non-y2k with msvc; '%#c' requests that a full year be used in the
// result string. Other OSes just use "%c".
PR_FormatTime(buf, sizeof buf,
#if defined(XP_PC) && !defined(XP_OS2)
#if defined(XP_PC) && !defined(XP_OS2)
"%#c",
#else
#else
"%c",
#endif
#endif
&prtime);
lastModified.AssignWithConversion(buf);
SetLastModified(lastModified);
}
}
}
static NS_DEFINE_IID(kCParserCID, NS_PARSER_IID);

16
content/html/document/src/nsImageDocument.cpp
View File

@@ -121,10 +121,14 @@ ImageListener::~ImageListener()
NS_IMPL_THREADSAFE_ISUPPORTS(ImageListener, NS_GET_IID(nsIStreamListener))
NS_IMETHODIMP
ImageListener::OnStartRequest(nsIChannel* channel, nsISupports *ctxt)
ImageListener::OnStartRequest(nsIRequest* request, nsISupports *ctxt)
{
nsresult rv;
nsIURI* uri;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (!channel) return NS_ERROR_NULL_POINTER;
rv = channel->GetURI(&uri);
if (NS_FAILED(rv)) return rv;
@@ -133,11 +137,11 @@ ImageListener::OnStartRequest(nsIChannel* channel, nsISupports *ctxt)
if (nsnull == mNextStream) {
return NS_ERROR_FAILURE;
}
return mNextStream->OnStartRequest(channel, ctxt);
return mNextStream->OnStartRequest(request, ctxt);
}
NS_IMETHODIMP
ImageListener::OnStopRequest(nsIChannel* channel, nsISupports *ctxt,
ImageListener::OnStopRequest(nsIRequest* request, nsISupports *ctxt,
nsresult status, const PRUnichar *errorMsg)
{
if(mDocument){
@@ -147,17 +151,17 @@ ImageListener::OnStopRequest(nsIChannel* channel, nsISupports *ctxt,
if (nsnull == mNextStream) {
return NS_ERROR_FAILURE;
}
return mNextStream->OnStopRequest(channel, ctxt, status, errorMsg);
return mNextStream->OnStopRequest(request, ctxt, status, errorMsg);
}
NS_IMETHODIMP
ImageListener::OnDataAvailable(nsIChannel* channel, nsISupports *ctxt,
ImageListener::OnDataAvailable(nsIRequest* request, nsISupports *ctxt,
nsIInputStream *inStr, PRUint32 sourceOffset, PRUint32 count)
{
if (nsnull == mNextStream) {
return NS_ERROR_FAILURE;
}
return mNextStream->OnDataAvailable(channel, ctxt, inStr, sourceOffset, count);
return mNextStream->OnDataAvailable(request, ctxt, inStr, sourceOffset, count);
}
//----------------------------------------------------------------------

33
content/xbl/src/nsXBLService.cpp
View File

@@ -260,37 +260,36 @@ nsXBLStreamListener::~nsXBLStreamListener()
}
}
/* void onDataAvailable (in nsIChannel channel, in nsISupports ctxt, in nsIInputStream inStr, in unsigned long sourceOffset, in unsigned long count); */
NS_IMETHODIMP
nsXBLStreamListener::OnDataAvailable(nsIChannel* aChannel, nsISupports* aCtxt, nsIInputStream* aInStr,
nsXBLStreamListener::OnDataAvailable(nsIRequest *request, nsISupports* aCtxt, nsIInputStream* aInStr,
PRUint32 aSourceOffset, PRUint32 aCount)
{
if (mInner)
return mInner->OnDataAvailable(aChannel, aCtxt, aInStr, aSourceOffset, aCount);
return mInner->OnDataAvailable(request, aCtxt, aInStr, aSourceOffset, aCount);
return NS_ERROR_FAILURE;
}
/* void onStartRequest (in nsIChannel channel, in nsISupports ctxt); */
NS_IMETHODIMP
nsXBLStreamListener::OnStartRequest(nsIChannel* aChannel, nsISupports* aCtxt)
nsXBLStreamListener::OnStartRequest(nsIRequest* request, nsISupports* aCtxt)
{
if (mInner)
return mInner->OnStartRequest(aChannel, aCtxt);
return mInner->OnStartRequest(request, aCtxt);
return NS_ERROR_FAILURE;
}
/* void onStopRequest (in nsIChannel channel, in nsISupports ctxt, in nsresult status, in wstring statusArg); */
NS_IMETHODIMP
nsXBLStreamListener::OnStopRequest(nsIChannel* aChannel, nsISupports* aCtxt, nsresult aStatus, const PRUnichar* aStatusArg)
nsXBLStreamListener::OnStopRequest(nsIRequest* request, nsISupports* aCtxt, nsresult aStatus, const PRUnichar* aStatusArg)
{
nsresult rv = NS_OK;
if (mInner) {
rv = mInner->OnStopRequest(aChannel, aCtxt, aStatus, aStatusArg);
rv = mInner->OnStopRequest(request, aCtxt, aStatus, aStatusArg);
}
if (NS_FAILED(rv) || NS_FAILED(aStatus))
{
nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
if (aChannel)
{
nsCOMPtr<nsIURI> channelURI;
@@ -1191,7 +1190,7 @@ nsXBLService::FetchBindingDocument(nsIContent* aBoundElement, nsIDocument* aBoun
nsCOMPtr<nsILoadGroup> loadGroup;
if (aBoundDocument)
aBoundDocument->GetDocumentLoadGroup(getter_AddRefs(loadGroup));
nsCOMPtr<nsIRequest> request;
nsCOMPtr<nsIChannel> channel;
rv = NS_OpenURI(getter_AddRefs(channel), aURI, nsnull, loadGroup);
if (NS_FAILED(rv)) return rv;
@@ -1233,18 +1232,22 @@ nsXBLService::FetchBindingDocument(nsIContent* aBoundElement, nsIDocument* aBoun
xblListener->AddRequest(req);
// Now kick off the async read.
channel->AsyncRead(xblListener, nsnull);
channel->AsyncOpen(xblListener, nsnull);
return NS_OK;
}
// Now do a blocking synchronous parse of the file.
nsCOMPtr<nsIInputStream> in;
PRUint32 sourceOffset = 0;
rv = channel->OpenInputStream(getter_AddRefs(in));
rv = channel->Open(getter_AddRefs(in));
// If we couldn't open the channel, then just return.
if (NS_FAILED(rv)) return NS_OK;
request = do_QueryInterface(channel);
NS_ASSERTION(request != nsnull, "no request info");
NS_ASSERTION(in != nsnull, "no input stream");
if (! in) return NS_ERROR_FAILURE;
@@ -1253,7 +1256,7 @@ nsXBLService::FetchBindingDocument(nsIContent* aBoundElement, nsIDocument* aBoun
if (! proxy)
return NS_ERROR_FAILURE;
listener->OnStartRequest(channel, nsnull);
listener->OnStartRequest(request, nsnull);
while (PR_TRUE) {
char buf[1024];
PRUint32 readCount;
@@ -1266,12 +1269,12 @@ nsXBLService::FetchBindingDocument(nsIContent* aBoundElement, nsIDocument* aBoun
proxy->SetBuffer(buf, readCount);
rv = listener->OnDataAvailable(channel, nsnull, proxy, sourceOffset, readCount);
rv = listener->OnDataAvailable(request, nsnull, proxy, sourceOffset, readCount);
sourceOffset += readCount;
if (NS_FAILED(rv))
break;
}
listener->OnStopRequest(channel, nsnull, NS_OK, nsnull);
listener->OnStopRequest(request, nsnull, NS_OK, nsnull);
// don't leak proxy!
proxy->Close();

6
content/xml/document/src/nsXMLContentSink.cpp
View File

@@ -1669,7 +1669,11 @@ nsXMLContentSink::OnStreamComplete(nsIStreamLoader* aLoader,
if (NS_OK == aStatus) {
{ // scope in block so nsCOMPtr released at one point
nsCOMPtr<nsIChannel> channel;
aLoader->GetChannel(getter_AddRefs(channel));
nsCOMPtr<nsIRequest> request;
aLoader->GetRequest(getter_AddRefs(request));
if (request)
channel = do_QueryInterface(request);
nsCOMPtr<nsIURI> url;
if (channel) {
channel->GetURI(getter_AddRefs(url));

11
content/xml/document/src/nsXMLDocument.cpp
View File

@@ -74,6 +74,11 @@
#include "nsIPrincipal.h"
#include "nsIAggregatePrincipal.h"
#include "nsCExternalHandlerService.h"
#include "nsIMIMEService.h"
#include "nsNetUtil.h"
#include "nsMimeTypes.h"
// XXX The XML world depends on the html atoms
#include "nsHTMLAtoms.h"
@@ -351,7 +356,7 @@ nsXMLDocument::Load(const nsAReadableString& aUrl)
}
// Start an asynchronous read of the XML document
rv = channel->AsyncRead(listener, nsnull);
rv = channel->AsyncOpen(listener, nsnull);
return rv;
}
@@ -381,7 +386,9 @@ nsXMLDocument::StartDocumentLoad(const char* aCommand,
rv = aChannel->GetURI(getter_AddRefs(aUrl));
if (NS_FAILED(rv)) return rv;
rv = aChannel->GetContentType(&aContentType);
nsCOMPtr<nsIMIMEService> MIMEService (do_GetService(NS_MIMESERVICE_CONTRACTID, &rv));
if (NS_FAILED(rv)) return rv;
rv = MIMEService->GetTypeFromURI(aUrl, &aContentType);
if (NS_SUCCEEDED(rv)) {
if ( 0 == PL_strcmp(aContentType, "text/html")) {

2
content/xml/document/src/nsXMLDocument.h
View File

@@ -52,7 +52,7 @@ public:
NS_IMETHOD GetContentType(nsAWritableString& aContentType) const;
NS_IMETHOD StartDocumentLoad(const char* aCommand,
nsIChannel* aChannel,
nsIChannel* channel,
nsILoadGroup* aLoadGroup,
nsISupports* aContainer,
nsIStreamListener **aDocListener,

102
content/xul/document/src/nsXULDocument.cpp
View File

@@ -127,6 +127,10 @@
#include "nsIDOMDocumentType.h"
#include "nsIXBLService.h"
#include "nsReadableUtils.h"
#include "nsCExternalHandlerService.h"
#include "nsIMIMEService.h"
#include "nsNetUtil.h"
#include "nsMimeTypes.h"
//----------------------------------------------------------------------
@@ -313,19 +317,19 @@ NS_IMPL_ISUPPORTS1(nsProxyLoadStream, nsIInputStream);
//----------------------------------------------------------------------
//
// PlaceholderChannel
// PlaceholderRequest
//
// This is a dummy channel implementation that we add to the load
// This is a dummy request implementation that we add to the load
// group. It ensures that EndDocumentLoad() in the docshell doesn't
// fire before we've finished building the complete document content
// model.
//
class PlaceholderChannel : public nsIChannel
class PlaceHolderRequest : public nsIChannel
{
protected:
PlaceholderChannel();
virtual ~PlaceholderChannel();
PlaceHolderRequest();
virtual ~PlaceHolderRequest();
static PRInt32 gRefCnt;
static nsIURI* gURI;
@@ -334,13 +338,12 @@ protected:
public:
static nsresult
Create(nsIChannel** aResult);
Create(nsIRequest** aResult);
NS_DECL_ISUPPORTS
// nsIRequest
NS_IMETHOD GetName(PRUnichar* *result) {
NS_NOTREACHED("PlaceholderChannel::GetName");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHOD IsPending(PRBool *_retval) { *_retval = PR_TRUE; return NS_OK; }
@@ -354,58 +357,45 @@ public:
NS_IMETHOD SetOriginalURI(nsIURI* aOriginalURI) { gURI = aOriginalURI; NS_ADDREF(gURI); return NS_OK; }
NS_IMETHOD GetURI(nsIURI* *aURI) { *aURI = gURI; NS_ADDREF(*aURI); return NS_OK; }
NS_IMETHOD SetURI(nsIURI* aURI) { gURI = aURI; NS_ADDREF(gURI); return NS_OK; }
NS_IMETHOD OpenInputStream(nsIInputStream **_retval) { *_retval = nsnull; return NS_OK; }
NS_IMETHOD OpenOutputStream(nsIOutputStream **_retval) { *_retval = nsnull; return NS_OK; }
NS_IMETHOD AsyncOpen(nsIStreamObserver *observer, nsISupports *ctxt) { return NS_OK; }
NS_IMETHOD AsyncRead(nsIStreamListener *listener, nsISupports *ctxt) { return NS_OK; }
NS_IMETHOD AsyncWrite(nsIStreamProvider *provider, nsISupports *ctxt) { return NS_OK; }
NS_IMETHOD Open(nsIInputStream **_retval) { *_retval = nsnull; return NS_OK; }
NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt) { return NS_OK; }
NS_IMETHOD GetLoadAttributes(nsLoadFlags *aLoadAttributes) { *aLoadAttributes = nsIChannel::LOAD_NORMAL; return NS_OK; }
NS_IMETHOD SetLoadAttributes(nsLoadFlags aLoadAttributes) { return NS_OK; }
NS_IMETHOD GetContentType(char * *aContentType) { *aContentType = nsnull; return NS_OK; }
NS_IMETHOD SetContentType(const char *aContentType) { return NS_OK; }
NS_IMETHOD GetContentLength(PRInt32 *aContentLength) { *aContentLength = 0; return NS_OK; }
NS_IMETHOD SetContentLength(PRInt32 aContentLength) { NS_NOTREACHED("SetContentLength"); NS_NOTREACHED("NOTREACHED"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetTransferOffset(PRUint32 *aTransferOffset) { NS_NOTREACHED("GetTransferOffset"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD SetTransferOffset(PRUint32 aTransferOffset) { NS_NOTREACHED("SetTransferOffset"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetTransferCount(PRInt32 *aTransferCount) { NS_NOTREACHED("GetTransferCount"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD SetTransferCount(PRInt32 aTransferCount) { NS_NOTREACHED("SetTransferCount"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetBufferSegmentSize(PRUint32 *aBufferSegmentSize) { NS_NOTREACHED("GetBufferSegmentSize"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD SetBufferSegmentSize(PRUint32 aBufferSegmentSize) { NS_NOTREACHED("SetBufferSegmentSize"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetBufferMaxSize(PRUint32 *aBufferMaxSize) { NS_NOTREACHED("GetBufferMaxSize"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD SetBufferMaxSize(PRUint32 aBufferMaxSize) { NS_NOTREACHED("SetBufferMaxSize"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetLocalFile(nsIFile* *result) { NS_NOTREACHED("GetLocalFile"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetPipeliningAllowed(PRBool *aPipeliningAllowed) { *aPipeliningAllowed = PR_FALSE; return NS_OK; }
NS_IMETHOD SetPipeliningAllowed(PRBool aPipeliningAllowed) { NS_NOTREACHED("SetPipeliningAllowed"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetOwner(nsISupports * *aOwner) { *aOwner = nsnull; return NS_OK; }
NS_IMETHOD SetOwner(nsISupports * aOwner) { return NS_OK; }
NS_IMETHOD GetLoadGroup(nsILoadGroup * *aLoadGroup) { *aLoadGroup = mLoadGroup; NS_IF_ADDREF(*aLoadGroup); return NS_OK; }
NS_IMETHOD SetLoadGroup(nsILoadGroup * aLoadGroup) { mLoadGroup = aLoadGroup; return NS_OK; }
NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor * *aNotificationCallbacks) { *aNotificationCallbacks = nsnull; return NS_OK; }
NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor * aNotificationCallbacks) { return NS_OK; }
NS_IMETHOD GetSecurityInfo(nsISupports **info) {*info = nsnull; return NS_OK;}
NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo) { *aSecurityInfo = nsnull; return NS_OK; }
NS_IMETHOD GetContentType(char * *aContentType) { *aContentType = nsnull; return NS_OK; }
NS_IMETHOD SetContentType(const char * aContentType) { return NS_OK; }
NS_IMETHOD GetContentLength(PRInt32 *aContentLength) { return NS_OK; }
NS_IMETHOD SetContentLength(PRInt32 aContentLength) { return NS_OK; }
};
PRInt32 PlaceholderChannel::gRefCnt;
nsIURI* PlaceholderChannel::gURI;
PRInt32 PlaceHolderRequest::gRefCnt;
nsIURI* PlaceHolderRequest::gURI;
NS_IMPL_ADDREF(PlaceholderChannel);
NS_IMPL_RELEASE(PlaceholderChannel);
NS_IMPL_QUERY_INTERFACE2(PlaceholderChannel, nsIRequest, nsIChannel);
NS_IMPL_ADDREF(PlaceHolderRequest);
NS_IMPL_RELEASE(PlaceHolderRequest);
NS_IMPL_QUERY_INTERFACE2(PlaceHolderRequest, nsIRequest, nsIChannel);
nsresult
PlaceholderChannel::Create(nsIChannel** aResult)
PlaceHolderRequest::Create(nsIRequest** aResult)
{
PlaceholderChannel* channel = new PlaceholderChannel();
if (! channel)
PlaceHolderRequest* request = new PlaceHolderRequest();
if (! request)
return NS_ERROR_OUT_OF_MEMORY;
*aResult = channel;
*aResult = request;
NS_ADDREF(*aResult);
return NS_OK;
}
PlaceholderChannel::PlaceholderChannel()
PlaceHolderRequest::PlaceHolderRequest()
{
NS_INIT_REFCNT();
@@ -417,7 +407,7 @@ PlaceholderChannel::PlaceholderChannel()
}
PlaceholderChannel::~PlaceholderChannel()
PlaceHolderRequest::~PlaceHolderRequest()
{
if (--gRefCnt == 0) {
NS_IF_RELEASE(gURI);
@@ -773,8 +763,9 @@ nsXULDocument::StartDocumentLoad(const char* aCommand,
// certain hacks (cough, the directory viewer) need to be able to
// StartDocumentLoad() before the channel's content type has been
// detected.
nsXPIDLCString contentType;
(void) aChannel->GetContentType(getter_Copies(contentType));
aChannel->GetContentType(getter_Copies(contentType));
if (contentType && PL_strcmp(contentType, "text/cached-xul") == 0) {
// Look in the chrome cache: we've got this puppy loaded
@@ -4943,16 +4934,16 @@ nsXULDocument::PrepareToWalk()
// Add a dummy channel to the load group as a placeholder for the document
// load
rv = PlaceholderChannel::Create(getter_AddRefs(mPlaceholderChannel));
rv = PlaceHolderRequest::Create(getter_AddRefs(mPlaceHolderRequest));
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsILoadGroup> group = do_QueryReferent(mDocumentLoadGroup);
if (group) {
rv = mPlaceholderChannel->SetLoadGroup(group);
nsCOMPtr<nsIChannel> channel = do_QueryInterface(mPlaceHolderRequest);
rv = channel->SetLoadGroup(group);
if (NS_FAILED(rv)) return rv;
rv = group->AddChannel(mPlaceholderChannel, nsnull);
rv = group->AddRequest(mPlaceHolderRequest, nsnull);
if (NS_FAILED(rv)) return rv;
}
}
@@ -5296,10 +5287,10 @@ nsXULDocument::ResumeWalk()
// docshell, and run the onload handlers, etc.
nsCOMPtr<nsILoadGroup> group = do_QueryReferent(mDocumentLoadGroup);
if (group) {
rv = group->RemoveChannel(mPlaceholderChannel, nsnull, NS_OK, nsnull);
rv = group->RemoveRequest(mPlaceHolderRequest, nsnull, NS_OK, nsnull);
if (NS_FAILED(rv)) return rv;
mPlaceholderChannel = nsnull;
mPlaceHolderRequest = nsnull;
}
return rv;
}
@@ -5361,8 +5352,11 @@ nsXULDocument::OnStreamComplete(nsIStreamLoader* aLoader,
{
if (aLoader)
{
nsCOMPtr<nsIRequest> request;
nsCOMPtr<nsIChannel> channel;
aLoader->GetChannel(getter_AddRefs(channel));
aLoader->GetRequest(getter_AddRefs(request));
if (request)
channel = do_QueryInterface(request);
if (channel)
{
nsCOMPtr<nsIURI> uri;
@@ -6527,14 +6521,14 @@ nsXULDocument::CachedChromeStreamListener::~CachedChromeStreamListener()
NS_IMPL_ISUPPORTS2(nsXULDocument::CachedChromeStreamListener, nsIStreamObserver, nsIStreamListener);
NS_IMETHODIMP
nsXULDocument::CachedChromeStreamListener::OnStartRequest(nsIChannel* aChannel, nsISupports* acontext)
nsXULDocument::CachedChromeStreamListener::OnStartRequest(nsIRequest *request, nsISupports* acontext)
{
return NS_OK;
}
NS_IMETHODIMP
nsXULDocument::CachedChromeStreamListener::OnStopRequest(nsIChannel* aChannel,
nsXULDocument::CachedChromeStreamListener::OnStopRequest(nsIRequest *request,
nsISupports* aContext,
nsresult aStatus,
const PRUnichar* aErrorMsg)
@@ -6549,7 +6543,7 @@ nsXULDocument::CachedChromeStreamListener::OnStopRequest(nsIChannel* aChannel,
NS_IMETHODIMP
nsXULDocument::CachedChromeStreamListener::OnDataAvailable(nsIChannel* aChannel,
nsXULDocument::CachedChromeStreamListener::OnDataAvailable(nsIRequest *request,
nsISupports* aContext,
nsIInputStream* aInStr,
PRUint32 aSourceOffset,
@@ -6579,14 +6573,14 @@ nsXULDocument::ParserObserver::~ParserObserver()
NS_IMPL_ISUPPORTS1(nsXULDocument::ParserObserver, nsIStreamObserver);
NS_IMETHODIMP
nsXULDocument::ParserObserver::OnStartRequest(nsIChannel* aChannel,
nsXULDocument::ParserObserver::OnStartRequest(nsIRequest *request,
nsISupports* aContext)
{
return NS_OK;
}
NS_IMETHODIMP
nsXULDocument::ParserObserver::OnStopRequest(nsIChannel* aChannel,
nsXULDocument::ParserObserver::OnStopRequest(nsIRequest *request,
nsISupports* aContext,
nsresult aStatus,
const PRUnichar* aErrorMsg)
@@ -6598,6 +6592,10 @@ nsXULDocument::ParserObserver::OnStopRequest(nsIChannel* aChannel,
// walk along.
#define YELL_IF_MISSING_OVERLAY 1
#if defined(DEBUG) || defined(YELL_IF_MISSING_OVERLAY)
nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
if (!aChannel) return NS_ERROR_FAILURE;
nsCOMPtr<nsIURI> uri;
aChannel->GetOriginalURI(getter_AddRefs(uri));

4
content/xul/document/src/nsXULDocument.h
View File

@@ -119,7 +119,7 @@ public:
NS_IMETHOD GetContentType(nsAWritableString& aContentType) const;
NS_IMETHOD StartDocumentLoad(const char* aCommand,
nsIChannel* aChannel,
nsIChannel *channel,
nsILoadGroup* aLoadGroup,
nsISupports* aContainer,
nsIStreamListener **aDocListener,
@@ -642,7 +642,7 @@ protected:
* A "dummy" channel that is used as a placeholder to signal document load
* completion.
*/
nsCOMPtr<nsIChannel> mPlaceholderChannel;
nsCOMPtr<nsIRequest> mPlaceHolderRequest;
/**
* Create a XUL template builder on the specified node if a 'datasources'

6
docshell/base/nsDSURIContentListener.cpp
View File

@@ -80,7 +80,7 @@ NS_IMETHODIMP nsDSURIContentListener::GetProtocolHandler(nsIURI* aURI,
NS_IMETHODIMP nsDSURIContentListener::DoContent(const char* aContentType,
nsURILoadCommand aCommand, const char* aWindowTarget,
nsIChannel* aOpenedChannel, nsIStreamListener** aContentHandler,
nsIRequest* request, nsIStreamListener** aContentHandler,
PRBool* aAbortProcess)
{
NS_ENSURE_ARG_POINTER(aContentHandler);
@@ -89,6 +89,8 @@ NS_IMETHODIMP nsDSURIContentListener::DoContent(const char* aContentType,
// determine if the channel has just been retargeted to us...
nsLoadFlags loadAttribs = 0;
nsCOMPtr<nsIChannel> aOpenedChannel = do_QueryInterface(request);
aOpenedChannel->GetLoadAttributes(&loadAttribs);
PRUint32 loadType = mDocShell->ConvertDocShellLoadInfoToLoadType((nsDocShellInfoLoadType) aCommand);
@@ -100,7 +102,7 @@ NS_IMETHODIMP nsDSURIContentListener::DoContent(const char* aContentType,
}
nsresult rv = mDocShell->CreateContentViewer(aContentType,
aOpenedChannel, aContentHandler);
request, aContentHandler);
if (NS_FAILED(rv)) return NS_ERROR_FAILURE; // it's okay if we don't know how to handle the content
if(loadAttribs & nsIChannel::LOAD_RETARGETED_DOCUMENT_URI)

19
docshell/base/nsDocShell.cpp
View File

@@ -2751,7 +2751,7 @@ NS_IMETHODIMP nsDocShell::CreateAboutBlankContentViewer()
}
NS_IMETHODIMP nsDocShell::CreateContentViewer(const char* aContentType,
nsIChannel* aOpenedChannel, nsIStreamListener** aContentHandler)
nsIRequest *request, nsIStreamListener** aContentHandler)
{
// Can we check the content type of the current content viewer
// and reuse it without destroying it and re-creating it?
@@ -2761,12 +2761,17 @@ NS_IMETHODIMP nsDocShell::CreateContentViewer(const char* aContentType,
// Instantiate the content viewer object
nsCOMPtr<nsIContentViewer> viewer;
if(NS_FAILED(NewContentViewerObj(aContentType, aOpenedChannel, loadGroup,
aContentHandler, getter_AddRefs(viewer))))
nsresult rv = NewContentViewerObj(aContentType, request, loadGroup,
aContentHandler, getter_AddRefs(viewer));
if(NS_FAILED(rv))
return NS_ERROR_FAILURE;
// we've created a new document so go ahead and call OnLoadingSite
mURIResultedInDocument = PR_TRUE;
nsCOMPtr<nsIChannel> aOpenedChannel = do_QueryInterface(request);
OnLoadingSite(aOpenedChannel);
// let's try resetting the load group if we need to...
@@ -2797,9 +2802,9 @@ NS_IMETHODIMP nsDocShell::CreateContentViewer(const char* aContentType,
aOpenedChannel->SetLoadAttributes(loadAttribs);
loadGroup->AddChannel(aOpenedChannel, nsnull);
loadGroup->AddRequest(request, nsnull);
if(currentLoadGroup)
currentLoadGroup->RemoveChannel(aOpenedChannel, nsnull, nsnull, nsnull);
currentLoadGroup->RemoveRequest(request, nsnull, nsnull, nsnull);
}
#ifdef SH_IN_FRAMES
@@ -2813,7 +2818,7 @@ NS_IMETHODIMP nsDocShell::CreateContentViewer(const char* aContentType,
}
nsresult nsDocShell::NewContentViewerObj(const char* aContentType,
nsIChannel* aOpenedChannel, nsILoadGroup* aLoadGroup,
nsIRequest *request, nsILoadGroup* aLoadGroup,
nsIStreamListener** aContentHandler, nsIContentViewer** aViewer)
{
//XXX This should probably be some category thing....
@@ -2841,6 +2846,8 @@ nsresult nsDocShell::NewContentViewerObj(const char* aContentType,
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsIChannel> aOpenedChannel = do_QueryInterface(request);
// Now create an instance of the content viewer
NS_ENSURE_SUCCESS(docLoaderFactory->CreateInstance(
(viewSource == mViewMode) ? "view-source" : "view",

4
docshell/base/nsDocShell.h
View File

@@ -191,9 +191,9 @@ protected:
NS_IMETHOD EnsureDeviceContext();
NS_IMETHOD CreateAboutBlankContentViewer();
NS_IMETHOD CreateContentViewer(const char* aContentType,
nsIChannel* aOpenedChannel, nsIStreamListener** aContentHandler);
nsIRequest *request, nsIStreamListener** aContentHandler);
NS_IMETHOD NewContentViewerObj(const char* aContentType,
nsIChannel* aOpenedChannel, nsILoadGroup* aLoadGroup,
nsIRequest *request, nsILoadGroup* aLoadGroup,
nsIStreamListener** aContentHandler, nsIContentViewer** aViewer);
NS_IMETHOD SetupNewViewer(nsIContentViewer* aNewViewer);

26
docshell/base/nsWebShell.cpp
View File

@@ -891,10 +891,10 @@ nsWebShell::GetLinkState(const char* aLinkURI, nsLinkState& aState)
// are cleaned up.
//
NS_IMETHODIMP
nsWebShell::OnStateChange(nsIWebProgress *aProgress, nsIRequest *aRequest,
nsWebShell::OnStateChange(nsIWebProgress *aProgress, nsIRequest *request,
PRInt32 aStateFlags, nsresult aStatus)
{
if (!aRequest) {
if (!request) {
return NS_OK;
}
@@ -903,7 +903,8 @@ nsWebShell::OnStateChange(nsIWebProgress *aProgress, nsIRequest *aRequest,
if (aProgress == webProgress.get()) {
nsCOMPtr<nsIURI> url;
nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
nsCOMPtr<nsIDocumentLoaderObserver> dlObserver;
(void) channel->GetURI(getter_AddRefs(url));
@@ -936,21 +937,21 @@ nsWebShell::OnStateChange(nsIWebProgress *aProgress, nsIRequest *aRequest,
* Fire the OnEndDocumentLoad of the DocLoaderobserver
*/
if(dlObserver && url) {
dlObserver->OnEndDocumentLoad(mDocLoader, channel, aStatus);
dlObserver->OnEndDocumentLoad(mDocLoader, request, aStatus);
}
}
}
}
if (aStateFlags & STATE_IS_REQUEST) {
nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (aStateFlags & STATE_START) {
/*
*Fire the OnStartDocumentLoad of the webshell observer
*/
if ((nsnull != mContainer) && (nsnull != mDocLoaderObserver)) {
mDocLoaderObserver->OnStartURLLoad(mDocLoader, channel);
mDocLoaderObserver->OnStartURLLoad(mDocLoader, request);
}
}
else if (aStateFlags & STATE_STOP) {
@@ -958,27 +959,26 @@ nsWebShell::OnStateChange(nsIWebProgress *aProgress, nsIRequest *aRequest,
*Fire the OnEndDocumentLoad of the webshell observer
*/
if ((nsnull != mContainer) && (nsnull != mDocLoaderObserver)) {
mDocLoaderObserver->OnEndURLLoad(mDocLoader, channel, aStatus);
mDocLoaderObserver->OnEndURLLoad(mDocLoader, request, aStatus);
}
}
}
return nsDocShell::OnStateChange(aProgress, aRequest, aStateFlags, aStatus);
return nsDocShell::OnStateChange(aProgress, request, aStateFlags, aStatus);
}
//----------------------------------------------------------------------
nsresult nsWebShell::EndPageLoad(nsIWebProgress *aProgress,
nsIChannel *aChannel,
nsIChannel* channel,
nsresult aStatus)
{
nsresult rv = NS_OK;
if(!aChannel)
if(!channel)
return NS_ERROR_NULL_POINTER;
nsCOMPtr<nsIURI> url;
rv = aChannel->GetURI(getter_AddRefs(url));
rv = channel->GetURI(getter_AddRefs(url));
if (NS_FAILED(rv)) return rv;
// clean up reload state for meta charset
@@ -993,7 +993,7 @@ nsresult nsWebShell::EndPageLoad(nsIWebProgress *aProgress,
// during this load handler.
//
nsCOMPtr<nsIWebShell> kungFuDeathGrip(this);
nsDocShell::EndPageLoad(aProgress, aChannel, aStatus);
nsDocShell::EndPageLoad(aProgress, channel, aStatus);
//
// If the page load failed, then deal with the error condition...

4
docshell/base/nsWebShell.h
View File

@@ -138,7 +138,7 @@ protected:
// sub-documents - ie. frames) has been completely loaded.
//
virtual nsresult EndPageLoad(nsIWebProgress *aProgress,
nsIChannel *aChannel,
nsIChannel* channel,
nsresult aStatus);
nsIEventQueue* mThreadEventQueue;
@@ -156,7 +156,7 @@ protected:
nsresult FireUnloadForChildren();
nsresult CreateViewer(nsIChannel* aChannel,
nsresult CreateViewer(nsIRequest* request,
const char* aContentType,
const char* aCommand,
nsIStreamListener** aResult);

2
editor/base/nsEditorShell.cpp
View File

@@ -4904,7 +4904,7 @@ NS_IMETHODIMP nsEditorShell::GetProtocolHandler(nsIURI *aURI, nsIProtocolHandler
}
/* void doContent (in string aContentType, in nsURILoadCommand aCommand, in string aWindowTarget, in nsIChannel aOpenedChannel, out nsIStreamListener aContentHandler, out boolean aAbortProcess); */
NS_IMETHODIMP nsEditorShell::DoContent(const char *aContentType, nsURILoadCommand aCommand, const char *aWindowTarget, nsIChannel *aOpenedChannel, nsIStreamListener **aContentHandler, PRBool *aAbortProcess)
NS_IMETHODIMP nsEditorShell::DoContent(const char *aContentType, nsURILoadCommand aCommand, const char *aWindowTarget, nsIRequest* request, nsIStreamListener **aContentHandler, PRBool *aAbortProcess)
{
NS_ENSURE_ARG_POINTER(aContentHandler);
NS_ENSURE_ARG_POINTER(aAbortProcess);

2
editor/composer/src/nsEditorShell.cpp
View File

@@ -4904,7 +4904,7 @@ NS_IMETHODIMP nsEditorShell::GetProtocolHandler(nsIURI *aURI, nsIProtocolHandler
}
/* void doContent (in string aContentType, in nsURILoadCommand aCommand, in string aWindowTarget, in nsIChannel aOpenedChannel, out nsIStreamListener aContentHandler, out boolean aAbortProcess); */
NS_IMETHODIMP nsEditorShell::DoContent(const char *aContentType, nsURILoadCommand aCommand, const char *aWindowTarget, nsIChannel *aOpenedChannel, nsIStreamListener **aContentHandler, PRBool *aAbortProcess)
NS_IMETHODIMP nsEditorShell::DoContent(const char *aContentType, nsURILoadCommand aCommand, const char *aWindowTarget, nsIRequest* request, nsIStreamListener **aContentHandler, PRBool *aAbortProcess)
{
NS_ENSURE_ARG_POINTER(aContentHandler);
NS_ENSURE_ARG_POINTER(aAbortProcess);

1
embedding/browser/Makefile.in
View File

@@ -35,4 +35,5 @@ ifdef MOZ_ENABLE_PHOTON
DIRS += photon
endif
include $(topsrcdir)/config/rules.mk

21
embedding/browser/activex/src/control/WebBrowserContainer.cpp
View File

@@ -388,8 +388,8 @@ NS_IMETHODIMP CWebBrowserContainer::GetProtocolHandler(nsIURI *aURI, nsIProtocol
}
/* void doContent (in string aContentType, in nsURILoadCommand aCommand, in string aWindowTarget, in nsIChannel aOpenedChannel, out nsIStreamListener aContentHandler, out boolean aAbortProcess); */
NS_IMETHODIMP CWebBrowserContainer::DoContent(const char *aContentType, nsURILoadCommand aCommand, const char *aWindowTarget, nsIChannel *aOpenedChannel, nsIStreamListener **aContentHandler, PRBool *aAbortProcess)
/* void doContent (in string aContentType, in nsURILoadCommand aCommand, in string aWindowTarget, in nsIRequest request, out nsIStreamListener aContentHandler, out boolean aAbortProcess); */
NS_IMETHODIMP CWebBrowserContainer::DoContent(const char *aContentType, nsURILoadCommand aCommand, const char *aWindowTarget, nsIRequest *request, nsIStreamListener **aContentHandler, PRBool *aAbortProcess)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
@@ -714,7 +714,7 @@ CWebBrowserContainer::GetPersistence(PRBool* aPersistX, PRBool* aPersistY,
NS_IMETHODIMP
CWebBrowserContainer::OnStartRequest(nsIChannel* aChannel, nsISupports* aContext)
CWebBrowserContainer::OnStartRequest(nsIRequest *request, nsISupports* aContext)
{
USES_CONVERSION;
NG_TRACE(_T("CWebBrowserContainer::OnStartRequest(...)\n"));
@@ -724,7 +724,7 @@ CWebBrowserContainer::OnStartRequest(nsIChannel* aChannel, nsISupports* aContext
NS_IMETHODIMP
CWebBrowserContainer::OnStopRequest(nsIChannel* aChannel, nsISupports* aContext, nsresult aStatus, const PRUnichar* aMsg)
CWebBrowserContainer::OnStopRequest(nsIRequest *request, nsISupports* aContext, nsresult aStatus, const PRUnichar* aMsg)
{
USES_CONVERSION;
NG_TRACE(_T("CWebBrowserContainer::OnStopRequest(..., %d, \"%s\")\n"), (int) aStatus, W2T((PRUnichar *) aMsg));
@@ -758,7 +758,7 @@ CWebBrowserContainer::OnStartDocumentLoad(nsIDocumentLoader* loader, nsIURI* pUR
// we need this to fire the document complete
NS_IMETHODIMP
CWebBrowserContainer::OnEndDocumentLoad(nsIDocumentLoader* loader, nsIChannel *aChannel, nsresult aStatus)
CWebBrowserContainer::OnEndDocumentLoad(nsIDocumentLoader* loader, nsIRequest *request, nsresult aStatus)
{
NG_TRACE(_T("CWebBrowserContainer::OnEndDocumentLoad(..., \"\")\n"));
@@ -776,6 +776,9 @@ CWebBrowserContainer::OnEndDocumentLoad(nsIDocumentLoader* loader, nsIChannel *a
char* aString = nsnull;
nsIURI* pURI = nsnull;
nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
if (!aChannel) return NS_ERROR_NULL_POINTER;
aChannel->GetURI(&pURI);
if (pURI == nsnull)
{
@@ -804,7 +807,7 @@ CWebBrowserContainer::OnEndDocumentLoad(nsIDocumentLoader* loader, nsIChannel *a
NS_IMETHODIMP
CWebBrowserContainer::OnStartURLLoad(nsIDocumentLoader* loader, nsIChannel* aChannel)
CWebBrowserContainer::OnStartURLLoad(nsIDocumentLoader* loader, nsIRequest *request)
{
NG_TRACE(_T("CWebBrowserContainer::OnStartURLLoad(..., \"\")\n"));
@@ -815,7 +818,7 @@ CWebBrowserContainer::OnStartURLLoad(nsIDocumentLoader* loader, nsIChannel* aCha
NS_IMETHODIMP
CWebBrowserContainer::OnProgressURLLoad(nsIDocumentLoader* loader, nsIChannel* aChannel, PRUint32 aProgress, PRUint32 aProgressMax)
CWebBrowserContainer::OnProgressURLLoad(nsIDocumentLoader* loader, nsIRequest *request, PRUint32 aProgress, PRUint32 aProgressMax)
{
USES_CONVERSION;
NG_TRACE(_T("CWebBrowserContainer::OnProgress(..., \"%d\", \"%d\")\n"), (int) aProgress, (int) aProgressMax);
@@ -825,7 +828,7 @@ CWebBrowserContainer::OnProgressURLLoad(nsIDocumentLoader* loader, nsIChannel* a
NS_IMETHODIMP
CWebBrowserContainer::OnStatusURLLoad(nsIDocumentLoader* loader, nsIChannel* aChannel, nsString& aMsg)
CWebBrowserContainer::OnStatusURLLoad(nsIDocumentLoader* loader, nsIRequest *request, nsString& aMsg)
{
NG_TRACE(_T("CWebBrowserContainer::OnStatusURLLoad(..., \"\")\n"));
@@ -840,7 +843,7 @@ CWebBrowserContainer::OnStatusURLLoad(nsIDocumentLoader* loader, nsIChannel* aCh
NS_IMETHODIMP
CWebBrowserContainer::OnEndURLLoad(nsIDocumentLoader* loader, nsIChannel* channel, nsresult aStatus)
CWebBrowserContainer::OnEndURLLoad(nsIDocumentLoader* loader, nsIRequest *request, nsresult aStatus)
{
NG_TRACE(_T("CWebBrowserContainer::OnEndURLLoad(..., \"\")\n"));

11
embedding/browser/gtk/src/GtkMozEmbedChrome.cpp
View File

@@ -264,7 +264,8 @@ NS_IMETHODIMP GtkMozEmbedChrome::OpenStream (const char *aBaseURI, const char *a
return rv;
// start our request
rv = mStreamListener->OnStartRequest(mChannel, NULL);
nsCOMPtr<nsIRequest> request = do_QueryInterface(mChannel);
rv = mStreamListener->OnStartRequest(request, NULL);
if (NS_FAILED(rv))
return rv;
@@ -281,7 +282,8 @@ NS_IMETHODIMP GtkMozEmbedChrome::AppendToStream (const char *aData, gint32 aLen)
rv = embedStream->Append(aData, aLen);
if (NS_FAILED(rv))
return rv;
rv = mStreamListener->OnDataAvailable(mChannel,
nsCOMPtr<nsIRequest> request = do_QueryInterface(mChannel);
rv = mStreamListener->OnDataAvailable(request,
NULL,
mStream,
mOffset, /* offset */
@@ -297,7 +299,8 @@ NS_IMETHODIMP GtkMozEmbedChrome::CloseStream (void)
nsresult rv;
NS_ENSURE_STATE(mDoingStream);
mDoingStream = PR_FALSE;
rv = mStreamListener->OnStopRequest(mChannel,
nsCOMPtr<nsIRequest> request = do_QueryInterface(mChannel);
rv = mStreamListener->OnStopRequest(request,
NULL,
NS_OK,
NULL);
@@ -531,7 +534,7 @@ NS_IMETHODIMP GtkMozEmbedChrome::GetProtocolHandler(nsIURI *aURI, nsIProtocolHan
}
NS_IMETHODIMP GtkMozEmbedChrome::DoContent(const char *aContentType, nsURILoadCommand aCommand,
const char *aWindowTarget, nsIChannel *aOpenedChannel,
const char *aWindowTarget, nsIRequest *request,
nsIStreamListener **aContentHandler, PRBool *aAbortProcess)
{
PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("GtkMozEmbedChrome::DoContent\n"));

2
embedding/browser/webBrowser/nsWBURIContentListener.cpp
View File

@@ -93,7 +93,7 @@ NS_IMETHODIMP nsWBURIContentListener::GetProtocolHandler(nsIURI* aURI,
NS_IMETHODIMP nsWBURIContentListener::DoContent(const char* aContentType,
nsURILoadCommand aCommand, const char* aWindowTarget,
nsIChannel* aOpenedChannel, nsIStreamListener** aContentHandler,
nsIRequest* request, nsIStreamListener** aContentHandler,
PRBool* aAbortProcess)
{
NS_ERROR("Hmmmm, why is this getting called on this object?");

57
embedding/browser/webBrowser/nsWebBrowserPersist.cpp
View File

@@ -86,7 +86,7 @@ void nsWebBrowserPersist::CleanUp()
mOutputStream->Close();
mOutputStream = nsnull;
}
mOutputChannel = nsnull;
mOutputTransport = nsnull;
}
NS_IMPL_ADDREF(nsWebBrowserPersist)
@@ -162,10 +162,6 @@ NS_IMETHODIMP nsWebBrowserPersist::SaveURI(nsIURI *aURI, nsIInputStream *aPostDa
}
}
// Query the content type
nsXPIDLCString contentType;
inputChannel->GetContentType(getter_Copies(contentType));
NS_DEFINE_CID(kFileTransportServiceCID, NS_FILETRANSPORTSERVICE_CID);
NS_WITH_SERVICE(nsIFileTransportService, fts, kFileTransportServiceCID, &rv);
@@ -188,7 +184,7 @@ NS_IMETHODIMP nsWebBrowserPersist::SaveURI(nsIURI *aURI, nsIInputStream *aPostDa
}
// Open a channel on the local file
nsCOMPtr<nsIChannel> outputChannel;
nsCOMPtr<nsITransport> outputChannel;
rv = fts->CreateTransport(file, PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE,
0664, getter_AddRefs(outputChannel));
if (NS_FAILED(rv))
@@ -197,10 +193,12 @@ NS_IMETHODIMP nsWebBrowserPersist::SaveURI(nsIURI *aURI, nsIInputStream *aPostDa
return NS_ERROR_FAILURE;
}
mOutputChannel = outputChannel;
mOutputTransport = outputChannel;
//dougt wtf?! why both a async and sync read?
// Read from the input channel
rv = inputChannel->AsyncRead(this, nsnull);
rv = inputChannel->AsyncOpen(this, nsnull);
if (NS_FAILED(rv))
{
OnEndDownload();
@@ -208,7 +206,7 @@ NS_IMETHODIMP nsWebBrowserPersist::SaveURI(nsIURI *aURI, nsIInputStream *aPostDa
}
nsCOMPtr<nsIInputStream> inStream;
rv = inputChannel->OpenInputStream(getter_AddRefs(inStream));
rv = inputChannel->Open(getter_AddRefs(inStream));
if (NS_FAILED(rv))
{
OnEndDownload();
@@ -219,7 +217,10 @@ NS_IMETHODIMP nsWebBrowserPersist::SaveURI(nsIURI *aURI, nsIInputStream *aPostDa
mInputStream = inStream;
// Get the output channel ready for writing
rv = NS_AsyncWriteFromStream(outputChannel, inStream, NS_STATIC_CAST(nsIStreamObserver *, this), nsnull);
nsCOMPtr<nsIRequest> writeRequest;
rv = NS_AsyncWriteFromStream(getter_AddRefs(writeRequest),
outputChannel, inStream, 0, 0, 0,
NS_STATIC_CAST(nsIStreamObserver*, this), nsnull);
if (NS_FAILED(rv))
{
OnEndDownload();
@@ -394,15 +395,13 @@ NS_IMETHODIMP nsWebBrowserPersist::OnProgress(PRUint32 aStatus, nsIURI *aURI, PR
//*****************************************************************************
/* void onStartRequest (in nsIChannel channel, in nsISupports ctxt); */
NS_IMETHODIMP nsWebBrowserPersist::OnStartRequest(nsIChannel *channel, nsISupports *ctxt)
NS_IMETHODIMP nsWebBrowserPersist::OnStartRequest(nsIRequest* request, nsISupports *ctxt)
{
nsresult rv = mOutputChannel->OpenOutputStream(getter_AddRefs(mOutputStream));
nsresult rv = mOutputTransport->OpenOutputStream(0, -1, 0, getter_AddRefs(mOutputStream));
return rv;
}
/* void onStopRequest (in nsIChannel channel, in nsISupports ctxt, in nsresult status, in wstring statusArg); */
NS_IMETHODIMP nsWebBrowserPersist::OnStopRequest(nsIChannel *channel, nsISupports *ctxt, nsresult status, const PRUnichar *statusArg)
NS_IMETHODIMP nsWebBrowserPersist::OnStopRequest(nsIRequest* request, nsISupports *ctxt, nsresult status, const PRUnichar *statusArg)
{
OnEndDownload();
CleanUp();
@@ -415,7 +414,7 @@ NS_IMETHODIMP nsWebBrowserPersist::OnStopRequest(nsIChannel *channel, nsISupport
//*****************************************************************************
NS_IMETHODIMP nsWebBrowserPersist::OnDataAvailable(nsIChannel *aChannel, nsISupports *aContext, nsIInputStream *aIStream, PRUint32 aOffset, PRUint32 aLength)
NS_IMETHODIMP nsWebBrowserPersist::OnDataAvailable(nsIRequest* request, nsISupports *aContext, nsIInputStream *aIStream, PRUint32 aOffset, PRUint32 aLength)
{
nsresult rv = NS_OK;
unsigned long bytesRemaining = aLength;
@@ -453,9 +452,9 @@ NS_IMETHODIMP nsWebBrowserPersist::OnDataAvailable(nsIChannel *aChannel, nsISupp
// Cancel reading?
if (cancel)
{
if (aChannel)
if (request)
{
aChannel->Cancel(NS_BINDING_ABORTED);
request->Cancel(NS_BINDING_ABORTED);
}
CleanUp();
OnEndDownload();
@@ -544,8 +543,6 @@ nsWebBrowserPersist::CleanupURIMap(nsHashKey *aKey, void *aData, void* closure)
nsresult
nsWebBrowserPersist::OnWalkDOMNode(nsIDOMNode *aNode, PRBool *aAbort)
{
nsresult rv = NS_OK;
// Test the node to see if it's an image, frame, iframe, css, js
nsCOMPtr<nsIDOMHTMLImageElement> nodeAsImage = do_QueryInterface(aNode);
if (nodeAsImage)
@@ -613,8 +610,6 @@ nsWebBrowserPersist::OnWalkDOMNode(nsIDOMNode *aNode, PRBool *aAbort)
nsresult
nsWebBrowserPersist::CloneNodeWithFixedUpURIAttributes(nsIDOMNode *aNodeIn, nsIDOMNode **aNodeOut)
{
nsresult rv = NS_OK;
*aNodeOut = nsnull;
// Test the node to see if it's an image, frame, iframe, css, js
@@ -892,13 +887,20 @@ nsWebBrowserPersist::MakeAndStoreLocalFilenameInURIMap(const char *aURI, nsStrin
// Create a unique file name for the uri
MakeFilenameFromURI(uri, inputChannel, filename);
// Query the content type
nsXPIDLCString contentType;
inputChannel->GetContentType(getter_Copies(contentType));
if (!mMIMEService)
{
mMIMEService = do_GetService(NS_MIMESERVICE_CONTRACTID);
if (!mMIMEService)
return NS_ERROR_FAILURE;
}
// Strap on the file extension using the mime lookup service
if (mMIMEService)
{
nsXPIDLCString contentType;
rv = mMIMEService->GetTypeFromURI(uri, getter_Copies(contentType));
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIMIMEInfo> mimeInfo;
mMIMEService->GetFromMIMEType(contentType, getter_AddRefs(mimeInfo));
if (mimeInfo)
@@ -914,7 +916,6 @@ nsWebBrowserPersist::MakeAndStoreLocalFilenameInURIMap(const char *aURI, nsStrin
filename.Append(newExt);
}
}
}
// Store the file name
URIData *data = new URIData;

4
embedding/browser/webBrowser/nsWebBrowserPersist.h
View File

@@ -32,7 +32,7 @@
#include "nsIChannel.h"
#include "nsIStyleSheet.h"
#include "nsIDocumentEncoder.h"
#include "nsITransport.h"
#include "nsHashtable.h"
#include "nsIWebBrowserPersist.h"
@@ -95,7 +95,7 @@ private:
nsCOMPtr<nsIMIMEService> mMIMEService;
nsCOMPtr<nsIChannel> mInputChannel;
nsCOMPtr<nsIInputStream> mInputStream;
nsCOMPtr<nsIChannel> mOutputChannel;
nsCOMPtr<nsITransport> mOutputTransport;
nsCOMPtr<nsIOutputStream> mOutputStream;
nsCOMPtr<nsIURI> mBaseURI;
nsCOMPtr<nsIURI> mURI;

10
extensions/cookie/nsCookieHTTPNotify.cpp
View File

@@ -162,8 +162,10 @@ nsCookieHTTPNotify::ModifyRequest(nsISupports *aContext)
nsCOMPtr<nsIChannel> pChannel;
if (pLoadGroup) {
rv = pLoadGroup->GetDefaultLoadChannel(getter_AddRefs(pChannel));
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIRequest> pRequest;
rv = pLoadGroup->GetDefaultLoadRequest(getter_AddRefs(pRequest));
if (pRequest)
pChannel = do_QueryInterface(pRequest);
}
nsCOMPtr<nsIURI> pFirstURL;
@@ -222,8 +224,10 @@ nsCookieHTTPNotify::AsyncExamineResponse(nsISupports *aContext)
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIChannel> pChannel;
if (pLoadGroup) {
rv = pLoadGroup->GetDefaultLoadChannel(getter_AddRefs(pChannel));
nsCOMPtr<nsIRequest> pRequest;
rv = pLoadGroup->GetDefaultLoadRequest(getter_AddRefs(pRequest));
if (NS_FAILED(rv)) return rv;
pChannel = do_QueryInterface(pRequest);
}
nsCOMPtr<nsIURI> pFirstURL;
if (pChannel) {

26
extensions/pics/src/nsPICS.cpp
View File

@@ -147,11 +147,11 @@ public:
// nsIDocumentLoaderObserver
NS_IMETHOD OnStartDocumentLoad(nsIDocumentLoader* loader, nsIURI* aURL, const char* aCommand);
NS_IMETHOD OnEndDocumentLoad(nsIDocumentLoader* loader, nsIChannel* channel, nsresult aStatus);
NS_IMETHOD OnStartURLLoad(nsIDocumentLoader* loader, nsIChannel* channel);
NS_IMETHOD OnProgressURLLoad(nsIDocumentLoader* loader, nsIChannel* channel, PRUint32 aProgress, PRUint32 aProgressMax);
NS_IMETHOD OnStatusURLLoad(nsIDocumentLoader* loader, nsIChannel* channel, nsString& aMsg);
NS_IMETHOD OnEndURLLoad(nsIDocumentLoader* loader, nsIChannel* channel, nsresult aStatus);
NS_IMETHOD OnEndDocumentLoad(nsIDocumentLoader* loader, nsIRequest *request, nsresult aStatus);
NS_IMETHOD OnStartURLLoad(nsIDocumentLoader* loader, nsIRequest *request);
NS_IMETHOD OnProgressURLLoad(nsIDocumentLoader* loader, nsIRequest *request, PRUint32 aProgress, PRUint32 aProgressMax);
NS_IMETHOD OnStatusURLLoad(nsIDocumentLoader* loader, nsIRequest *request, nsString& aMsg);
NS_IMETHOD OnEndURLLoad(nsIDocumentLoader* loader, nsIRequest *request, nsresult aStatus);
// NS_IMETHOD OnConnectionsComplete();
@@ -696,7 +696,7 @@ nsPICS::OnStartDocumentLoad(nsIDocumentLoader* loader,
NS_IMETHODIMP
nsPICS::OnEndDocumentLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
nsIRequest *request,
nsresult aStatus)
{
nsresult rv = NS_OK;
@@ -719,10 +719,14 @@ nsPICS::OnEndDocumentLoad(nsIDocumentLoader* loader,
}
NS_IMETHODIMP
nsPICS::OnStartURLLoad(nsIDocumentLoader* loader, nsIChannel* channel)
nsPICS::OnStartURLLoad(nsIDocumentLoader* loader, nsIRequest *request)
{
nsresult rv = NS_OK;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (!channel)
return NS_ERROR_FAILURE;
nsCOMPtr<nsIURI> aURL;
rv = channel->GetURI(getter_AddRefs(aURL));
if (NS_FAILED(rv)) return rv;
@@ -798,7 +802,7 @@ nsPICS::OnStartURLLoad(nsIDocumentLoader* loader, nsIChannel* channel)
NS_IMETHODIMP
nsPICS::OnProgressURLLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
nsIRequest *request,
PRUint32 aProgress,
PRUint32 aProgressMax)
{
@@ -809,7 +813,7 @@ nsPICS::OnProgressURLLoad(nsIDocumentLoader* loader,
NS_IMETHODIMP
nsPICS::OnStatusURLLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
nsIRequest *request,
nsString& aMsg)
{
if(!mPICSRatingsEnabled)
@@ -819,11 +823,13 @@ nsPICS::OnStatusURLLoad(nsIDocumentLoader* loader,
NS_IMETHODIMP
nsPICS::OnEndURLLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
nsIRequest *request,
nsresult aStatus)
{
nsresult rv;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
nsCOMPtr<nsIURI> aURL;
rv = channel->GetURI(getter_AddRefs(aURL));
if (NS_FAILED(rv)) return rv;

2
extensions/psm-glue/public/psm-glue.js
View File

@@ -9,3 +9,5 @@ pref("security.warn_entering_secure", true);
pref("security.warn_leaving_secure", true);
pref("security.warn_viewing_mixed", true);
pref("security.warn_submit_insecure", true);
pref("security.ui.enable", true);

29
extensions/psm-glue/src/nsPSMComponent.cpp
View File

@@ -719,12 +719,15 @@ NS_IMPL_ISUPPORTS(CertDownloader,NS_GET_IID(nsIStreamListener));
const PRInt32 kDefaultCertAllocLength = 2048;
NS_IMETHODIMP
CertDownloader::OnStartRequest(nsIChannel* channel, nsISupports* context)
CertDownloader::OnStartRequest(nsIRequest *request, nsISupports* context)
{
nsresult rv;
nsresult rv = NS_OK;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (channel)
rv = channel->GetContentLength(&mContentLength);
if (rv != NS_OK || mContentLength == -1)
if (!channel || rv != NS_OK || mContentLength == -1)
mContentLength = kDefaultCertAllocLength;
mBufferOffset = 0;
@@ -737,7 +740,7 @@ CertDownloader::OnStartRequest(nsIChannel* channel, nsISupports* context)
NS_IMETHODIMP
CertDownloader::OnDataAvailable(nsIChannel* channel,
CertDownloader::OnDataAvailable(nsIRequest *request,
nsISupports* context,
nsIInputStream *aIStream,
PRUint32 aSourceOffset,
@@ -776,7 +779,7 @@ CertDownloader::OnDataAvailable(nsIChannel* channel,
NS_IMETHODIMP
CertDownloader::OnStopRequest(nsIChannel* channel,
CertDownloader::OnStopRequest(nsIRequest *request,
nsISupports* context,
nsresult aStatus,
const PRUnichar* aMsg)
@@ -857,19 +860,22 @@ nsPSMComponent::HandleContent(const char * aContentType,
const char * aCommand,
const char * aWindowTarget,
nsISupports* aWindowContext,
nsIChannel * aChannel)
nsIRequest *request)
{
// We were called via CI. We better protect ourselves and addref.
NS_ADDREF_THIS();
nsresult rv = NS_OK;
if (!aChannel) return NS_ERROR_NULL_POINTER;
if (!request) return NS_ERROR_NULL_POINTER;
CMUint32 type = getPSMCertType(aContentType);
if (type != -1)
{
// I can't directly open the passed channel cause it fails :-(
nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
if (!aChannel)
return NS_ERROR_FAILURE;
nsCOMPtr<nsIURI> uri;
rv = aChannel->GetURI(getter_AddRefs(uri));
@@ -879,10 +885,11 @@ nsPSMComponent::HandleContent(const char * aContentType,
rv = NS_OpenURI(getter_AddRefs(channel), uri);
if (NS_FAILED(rv)) return rv;
return channel->AsyncRead(new CertDownloader(type), NS_STATIC_CAST(nsIPSMComponent*,this));
return channel->AsyncOpen(new CertDownloader(type), NS_STATIC_CAST(nsIPSMComponent*,this));
}
return NS_ERROR_NOT_IMPLEMENTED;
return NS_ERROR_FAILURE;
}
NS_IMPL_ISUPPORTS(CertContentListener, NS_GET_IID(nsIURIContentListener));
@@ -957,7 +964,7 @@ NS_IMETHODIMP
CertContentListener::DoContent(const char * aContentType,
nsURILoadCommand aCommand,
const char * aWindowTarget,
nsIChannel * aOpenedChannel,
nsIRequest * request,
nsIStreamListener ** aContentHandler,
PRBool * aAbortProcess)
{

2
extensions/transformiix/source/xml/parser/nsSyncLoader.cpp
View File

@@ -298,7 +298,7 @@ nsSyncLoader::LoadDocument(nsIURI* documentURI, nsIDOMDocument **_retval)
}
// Start reading from the channel
rv = channel->AsyncRead(listener, nsnull);
rv = channel->AsyncOpen(listener, nsnull);
if (NS_FAILED(rv)) {
if (modalEventQueue) {

26
extensions/xmlterm/ui/xmlterm-service.js
View File

@@ -114,10 +114,12 @@ function (iid) {
}
TelnetContentHandler.prototype.handleContent =
function (aContentType, aCommand, aWindowTarget, aSourceContext, aChannel)
function (aContentType, aCommand, aWindowTarget, aSourceContext, aRequest)
{
var e;
var aChannel = aRequest.QueryInterface(Components.interfaces.nsIChannel);
dump ("telnetLoader.handleContent (" + aContentType + ", " +
aCommand + ", " + aWindowTarget + ", " + aSourceContext + ", " +
aChannel.URI.spec + ")\n");
@@ -218,7 +220,10 @@ function (aURI)
//dump("gSystemPrincipal="+gSystemPrincipal+"\n");
// Cancel XUL request and release channel
temChannel.cancel(Components.results.NS_BINDING_ABORTED);
// why are you canceling here?! you have not even opened anything yet - dougt.
// temChannel.cancel(Components.results.NS_BINDING_ABORTED);
temChannel = null;
// Get current process directory
@@ -279,8 +284,6 @@ function (iid) {
}
/* nsIChannel */
BogusChannel.prototype.transferOffset = 0;
BogusChannel.prototype.transferCount = 0;
BogusChannel.prototype.loadAttributes = null;
BogusChannel.prototype.contentType = "x-application-telnet";
BogusChannel.prototype.contentLength = 0;
@@ -288,14 +291,10 @@ BogusChannel.prototype.owner = null;
BogusChannel.prototype.loadGroup = null;
BogusChannel.prototype.notificationCallbacks = null;
BogusChannel.prototype.securityInfo = null;
BogusChannel.prototype.bufferSegmentSize = 0;
BogusChannel.prototype.bufferMaxSize = 0;
BogusChannel.prototype.shouldCache = false;
BogusChannel.prototype.pipeliningAllowed = false;
BogusChannel.prototype.openInputStream =
BogusChannel.prototype.openOutputStream =
BogusChannel.prototype.asyncWrite =
BogusChannel.prototype.open =
BogusChannel.prototype.asyncOpen =
function ()
{
throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
@@ -307,12 +306,6 @@ function (observer, ctxt)
observer.onStartRequest (this, ctxt);
}
BogusChannel.prototype.asyncRead =
function (listener, ctxt)
{
return listener.onStartRequest (this, ctxt);
}
/* nsIRequest */
BogusChannel.prototype.isPending =
function ()
@@ -328,6 +321,7 @@ function (aStatus)
this.status = aStatus;
}
BogusChannel.prototype.parent =
BogusChannel.prototype.suspend =
BogusChannel.prototype.resume =
function ()

76
gfx/src/nsImageNetContextAsync.cpp
View File

@@ -98,7 +98,7 @@ public:
virtual int GetContentLength(ilIURL * aURL);
nsresult RemoveRequest(ImageConsumer *aConsumer);
nsresult RequestDone(ImageConsumer *aConsumer, nsIChannel* channel,
nsresult RequestDone(ImageConsumer *aConsumer, nsIRequest* request,
nsISupports* ctxt, nsresult status, const PRUnichar* aMsg);
nsVoidArray *mRequests; // WEAK references to |ImageConsumer|s
@@ -121,10 +121,10 @@ public:
NS_DECL_NSIURICONTENTLISTENER
NS_DECL_NSIINTERFACEREQUESTOR
void SetKeepPumpingData(nsIChannel* channel, nsISupports* context) {
NS_ADDREF(channel);
NS_IF_RELEASE(mChannel);
mChannel = channel;
void SetKeepPumpingData(nsIRequest* request, nsISupports* context) {
NS_ADDREF(request);
NS_IF_RELEASE(mRequest);
mRequest = request;
NS_IF_ADDREF(context);
NS_IF_RELEASE(mUserContext);
@@ -145,7 +145,7 @@ protected:
PRBool mFirstRead;
char *mBuffer;
PRInt32 mStatus;
nsIChannel* mChannel;
nsIRequest* mRequest;
nsISupports* mUserContext;
PRBool mIsMulti;
};
@@ -162,7 +162,7 @@ ImageConsumer::ImageConsumer(ilIURL *aURL, ImageNetContextImpl *aContext)
mStream = nsnull;
mBuffer = nsnull;
mStatus = 0;
mChannel = nsnull;
mRequest = nsnull;
mUserContext = nsnull;
mIsMulti = PR_FALSE;
}
@@ -262,7 +262,7 @@ NS_IMETHODIMP
ImageConsumer::DoContent(const char * aContentType,
nsURILoadCommand aCommand,
const char * aWindowTarget,
nsIChannel * aOpenedChannel,
nsIRequest * aOpenedChannel,
nsIStreamListener ** aContentHandler,
PRBool * aAbortProcess)
{
@@ -294,8 +294,10 @@ ImageConsumer::DoContent(const char * aContentType,
NS_IMETHODIMP
ImageConsumer::OnStartRequest(nsIChannel* channel, nsISupports* aContext)
ImageConsumer::OnStartRequest(nsIRequest* aRequest, nsISupports* aContext)
{
nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
PRUint32 httpStatus;
if (mInterrupted) {
mStatus = MK_INTERRUPTED;
@@ -318,7 +320,7 @@ ImageConsumer::OnStartRequest(nsIChannel* channel, nsISupports* aContext)
}
ilINetReader *reader = mURL->GetReader(); //ptn test: nsCOMPtr??
nsresult err= reader->FlushImgBuffer(); //flush current data in buffer before starting
/*nsresult err=*/ reader->FlushImgBuffer(); //flush current data in buffer before starting
nsresult rv = NS_OK;
char* aContentType = NULL;
@@ -353,13 +355,15 @@ ImageConsumer::OnStartRequest(nsIChannel* channel, nsISupports* aContext)
NS_IMETHODIMP
ImageConsumer::OnDataAvailable(nsIChannel* channel, nsISupports* aContext, nsIInputStream *pIStream,
PRUint32 offset, PRUint32 length)
ImageConsumer::OnDataAvailable(nsIRequest* request, nsISupports* aContext,
nsIInputStream *pIStream, PRUint32 offset, PRUint32 length)
{
PRUint32 max_read=0;
PRUint32 bytes_read = 0;
ilINetReader *reader = mURL->GetReader();
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (mInterrupted || mStatus != 0) {
mStatus = MK_INTERRUPTED;
reader->StreamAbort(mStatus);
@@ -482,12 +486,12 @@ ImageConsumer::KeepPumpingStream(nsITimer *aTimer, void *aClosure)
ImageConsumer *consumer = (ImageConsumer *)aClosure;
nsAutoString status;
consumer->OnStopRequest(consumer->mChannel, consumer->mUserContext,
consumer->OnStopRequest(consumer->mRequest, consumer->mUserContext,
NS_BINDING_SUCCEEDED, status.GetUnicode());
}
NS_IMETHODIMP
ImageConsumer::OnStopRequest(nsIChannel* channel, nsISupports* aContext, nsresult status, const PRUnichar* aMsg)
ImageConsumer::OnStopRequest(nsIRequest* request, nsISupports* aContext, nsresult status, const PRUnichar* aMsg)
{
if (mTimer) {
mTimer->Cancel();
@@ -506,12 +510,12 @@ ImageConsumer::OnStopRequest(nsIChannel* channel, nsISupports* aContext, nsresul
nsresult err = mStream->Available(&str_length);
if (NS_SUCCEEDED(err)) {
NS_ASSERTION((str_length > 0), "No data left in the stream!");
err = OnDataAvailable(channel, aContext, mStream, 0, str_length); // XXX fix offset
err = OnDataAvailable(request, aContext, mStream, 0, str_length); // XXX fix offset
if (NS_SUCCEEDED(err)) {
// If we still have the stream, there's still data to be
// pumped, so we set a timer to call us back again.
if (mStream) {
SetKeepPumpingData(channel, aContext);
SetKeepPumpingData(request, aContext);
nsresult rv;
mTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
@@ -550,7 +554,7 @@ ImageConsumer::OnStopRequest(nsIChannel* channel, nsISupports* aContext, nsresul
reader->NetRequestDone(mURL, mStatus);
NS_RELEASE(reader);
return mContext->RequestDone(this, channel, aContext, status, aMsg);
return mContext->RequestDone(this, request, aContext, status, aMsg);
}
void
@@ -583,7 +587,7 @@ ImageConsumer::~ImageConsumer()
if (mBuffer != nsnull) {
PR_DELETE(mBuffer);
}
NS_IF_RELEASE(mChannel);
NS_IF_RELEASE(mRequest);
NS_IF_RELEASE(mUserContext);
}
@@ -722,8 +726,10 @@ ImageNetContextImpl::GetContentLength (ilIURL * aURL)
rv = NS_OpenURI(getter_AddRefs(channel), nsurl, nsnull, group, sink);
if (NS_FAILED(rv)) return 0;
rv = channel->GetContentLength(&content_length);
// Why would this code ever return anything but zero. we don't do asyncread
// on the channel we create?
// Commenting this line for now TODO -gagan
//rv = channel->GetContentLength(&content_length);
return content_length;
}
@@ -785,14 +791,16 @@ ImageNetContextImpl::GetURL (ilIURL * aURL,
nsCOMPtr<nsIHTTPChannel> httpChannel = do_QueryInterface(channel);
if (httpChannel)
{
// Get the defloadchannel from the loadgroup-
nsCOMPtr<nsIChannel> defLoadChannel;
if (NS_SUCCEEDED(group->GetDefaultLoadChannel(
getter_AddRefs(defLoadChannel))) && defLoadChannel)
// Get the defloadRequest from the loadgroup-
nsCOMPtr<nsIRequest> defLoadRequest;
if (NS_SUCCEEDED(group->GetDefaultLoadRequest(
getter_AddRefs(defLoadRequest))) && defLoadRequest)
{
nsCOMPtr<nsIChannel> reqchannel = do_QueryInterface(defLoadRequest);
// Get the referrer from the loadchannel-
nsCOMPtr<nsIURI> referrer;
if (NS_SUCCEEDED(defLoadChannel->GetURI(getter_AddRefs(referrer))))
if (NS_SUCCEEDED(reqchannel->GetURI(getter_AddRefs(referrer))))
{
// Set the referrer-
httpChannel->SetReferrer(referrer,
@@ -826,7 +834,7 @@ ImageNetContextImpl::GetURL (ilIURL * aURL,
rv = pURILoader->OpenURI(channel, loadCmd, nsnull /* window target */,
window);
}
// rv = channel->AsyncRead(ic, nsnull);
// rv = channel->AsyncOpen(ic, nsnull);
if (NS_FAILED(rv)) goto error;
}
@@ -851,7 +859,7 @@ ImageNetContextImpl::RemoveRequest(ImageConsumer *aConsumer)
}
nsresult
ImageNetContextImpl::RequestDone(ImageConsumer *aConsumer, nsIChannel* channel,
ImageNetContextImpl::RequestDone(ImageConsumer *aConsumer, nsIRequest* request,
nsISupports* ctxt, nsresult status, const PRUnichar* aMsg)
{
RemoveRequest(aConsumer);
@@ -879,14 +887,18 @@ NS_NewImageNetContext(ilINetContext **aInstancePtrResult,
if(aLoadContext){
nsCOMPtr<nsILoadGroup> group (do_GetInterface(aLoadContext));
nsresult rv = group->GetDefaultLoadAttributes(&necko_attribs);
/*nsresult rv = */group->GetDefaultLoadAttributes(&necko_attribs);
/*
Need code to check freshness of necko cache.
*/
nsCOMPtr<nsIChannel> defLoadChannel;
if (NS_SUCCEEDED(group->GetDefaultLoadChannel(
getter_AddRefs(defLoadChannel))) && defLoadChannel)
defLoadChannel->GetLoadAttributes(&defchan_attribs);
nsCOMPtr<nsIRequest> defLoadRequest;
nsCOMPtr<nsIChannel> channel;
if (NS_SUCCEEDED(group->GetDefaultLoadRequest(
getter_AddRefs(defLoadRequest))) && defLoadRequest)
{
channel = do_QueryInterface(defLoadRequest);
if (channel) channel->GetLoadAttributes(&defchan_attribs);
}
#if defined( DEBUG )
if (image_net_context_async_log_module == NULL) {

5
gfx/src/nsImageNetContextSync.cpp
View File

@@ -218,6 +218,9 @@ ImageNetContextSyncImpl::GetURL(ilIURL* aURL,
if(aContentType){
nsCRT::free(aContentType);
}
}
if (!aContentType) {
aContentType = nsCRT::strdup("unknown");
}
if(nsCRT::strlen(aContentType) > 50){
@@ -227,7 +230,7 @@ ImageNetContextSyncImpl::GetURL(ilIURL* aURL,
aContentType = nsCRT::strdup("unknown");
}
rv = channel->OpenInputStream(&stream);
rv = channel->Open( &stream);
NS_RELEASE(channel);
if (NS_SUCCEEDED(rv)) {

10
htmlparser/robot/nsDebugRobot.cpp
View File

@@ -152,7 +152,7 @@ CStreamListener::OnStartDocumentLoad(nsIDocumentLoader* loader,
NS_IMETHODIMP
CStreamListener::OnEndDocumentLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
nsIRequest *request,
nsresult aStatus)
{
fputs("done.\n",stdout);
@@ -162,14 +162,14 @@ CStreamListener::OnEndDocumentLoad(nsIDocumentLoader* loader,
NS_IMETHODIMP
CStreamListener::OnStartURLLoad(nsIDocumentLoader* loader,
nsIChannel* channel)
nsIRequest *request)
{
return NS_OK;
}
NS_IMETHODIMP
CStreamListener::OnProgressURLLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
nsIRequest *request,
PRUint32 aProgress,
PRUint32 aProgressMax)
{
@@ -178,7 +178,7 @@ CStreamListener::OnProgressURLLoad(nsIDocumentLoader* loader,
NS_IMETHODIMP
CStreamListener::OnStatusURLLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
nsIRequest *request,
nsString& aMsg)
{
return NS_OK;
@@ -186,7 +186,7 @@ CStreamListener::OnStatusURLLoad(nsIDocumentLoader* loader,
NS_IMETHODIMP
CStreamListener::OnEndURLLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
nsIRequest *request,
nsresult aStatus)
{
return NS_OK;

4
htmlparser/src/CParserContext.cpp
View File

@@ -61,7 +61,7 @@ CParserContext::CParserContext(nsScanner* aScanner,
mContextType=eCTNone;
mCopyUnused=aCopyUnused;
mParserCommand=aCommand;
mChannel=0;
mRequest=0;
mValidator=0;
}
@@ -92,7 +92,7 @@ CParserContext::CParserContext(const CParserContext &aContext) : mMimeType() {
mStreamListenerState=aContext.mStreamListenerState;
mMultipart=aContext.mMultipart;
mContextType=aContext.mContextType;
mChannel=aContext.mChannel;
mRequest=aContext.mRequest;
mParserCommand=aContext.mParserCommand;
SetMimeType(aContext.mMimeType);
}

2
htmlparser/src/CParserContext.h
View File

@@ -72,7 +72,7 @@ public:
eContextType mContextType;
eAutoDetectResult mAutoDetectStatus;
eParserCommands mParserCommand; //tells us to viewcontent/viewsource/viewerrors...
nsIChannel* mChannel; // provided by necko to differnciate different input streams
nsIRequest* mRequest; // provided by necko to differnciate different input streams
nsScanner* mScanner;
nsIDTD* mDTD;

27
htmlparser/src/nsParser.cpp
View File

@@ -2062,11 +2062,11 @@ nsITokenizer* nsParser::GetTokenizer(void) {
* @return error code -- 0 if ok, non-zero if error.
*/
nsresult
nsParser::OnProgress(nsIChannel* channel, nsISupports* aContext, PRUint32 aProgress, PRUint32 aProgressMax)
nsParser::OnProgress(nsIRequest *request, nsISupports* aContext, PRUint32 aProgress, PRUint32 aProgressMax)
{
nsresult result=0;
if (nsnull != mProgressEventSink) {
mProgressEventSink->OnProgress(channel, aContext, aProgress, aProgressMax);
mProgressEventSink->OnProgress(request, aContext, aProgress, aProgressMax);
}
return result;
}
@@ -2079,12 +2079,12 @@ nsParser::OnProgress(nsIChannel* channel, nsISupports* aContext, PRUint32 aProgr
* @return error code -- 0 if ok, non-zero if error.
*/
nsresult
nsParser::OnStatus(nsIChannel* channel, nsISupports* aContext,
nsParser::OnStatus(nsIRequest *request, nsISupports* aContext,
nsresult aStatus, const PRUnichar* aStatusArg)
{
nsresult rv;
if (nsnull != mProgressEventSink) {
rv = mProgressEventSink->OnStatus(channel, aContext, aStatus, aStatusArg);
rv = mProgressEventSink->OnStatus(request, aContext, aStatus, aStatusArg);
NS_ASSERTION(NS_SUCCEEDED(rv), "dropping error result");
}
return NS_OK;
@@ -2102,19 +2102,22 @@ nsParser::OnStatus(nsIChannel* channel, nsISupports* aContext,
* @param
* @return error code -- 0 if ok, non-zero if error.
*/
nsresult nsParser::OnStartRequest(nsIChannel* channel, nsISupports* aContext) {
nsresult nsParser::OnStartRequest(nsIRequest *request, nsISupports* aContext) {
NS_PRECONDITION((eNone==mParserContext->mStreamListenerState),kBadListenerInit);
if (nsnull != mObserver) {
mObserver->OnStartRequest(channel, aContext);
mObserver->OnStartRequest(request, aContext);
}
mParserContext->mStreamListenerState=eOnStart;
mParserContext->mAutoDetectStatus=eUnknownDetect;
mParserContext->mChannel=channel;
mParserContext->mRequest=request;
mParserContext->mDTD=0;
nsresult rv;
char* contentType = nsnull;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
NS_ASSERTION(channel, "parser needs a channel to find a dtd");
rv = channel->GetContentType(&contentType);
if (NS_SUCCEEDED(rv))
{
@@ -2310,7 +2313,7 @@ ParserWriteFunc(nsIInputStream* in,
* @return error code (usually 0)
*/
nsresult nsParser::OnDataAvailable(nsIChannel* channel, nsISupports* aContext,
nsresult nsParser::OnDataAvailable(nsIRequest *request, nsISupports* aContext,
nsIInputStream *pIStream, PRUint32 sourceOffset, PRUint32 aLength)
{
@@ -2322,12 +2325,12 @@ NS_PRECONDITION(((eOnStart==mParserContext->mStreamListenerState)||(eOnDataAvail
CParserContext *theContext=mParserContext;
while(theContext) {
if(theContext->mChannel!=channel && theContext->mPrevContext)
if(theContext->mRequest!=request && theContext->mPrevContext)
theContext=theContext->mPrevContext;
else break;
}
if(theContext && theContext->mChannel==channel) {
if(theContext && theContext->mRequest==request) {
theContext->mStreamListenerState=eOnDataAvail;
@@ -2366,7 +2369,7 @@ NS_PRECONDITION(((eOnStart==mParserContext->mStreamListenerState)||(eOnDataAvail
* @param
* @return
*/
nsresult nsParser::OnStopRequest(nsIChannel* channel, nsISupports* aContext,
nsresult nsParser::OnStopRequest(nsIRequest *request, nsISupports* aContext,
nsresult status, const PRUnichar* aMsg)
{
@@ -2398,7 +2401,7 @@ nsresult nsParser::OnStopRequest(nsIChannel* channel, nsISupports* aContext,
// XXX Should we wait to notify our observers as well if the
// parser isn't yet enabled?
if (nsnull != mObserver) {
mObserver->OnStopRequest(channel, aContext, status, aMsg);
mObserver->OnStopRequest(request, aContext, status, aMsg);
}
#ifdef rickgdebug

2
htmlparser/tests/grabpage/grabpage.cpp
View File

@@ -237,7 +237,7 @@ PageGrabber::Grab(const nsString& aURL)
if(copier) {
NS_ADDREF(copier);
rv = channel->AsyncRead(copier, nsnull);
rv = channel->AsyncOpen(copier, nsnull);
if (NS_OK != rv) {
NS_RELEASE(copier);

5
intl/strres/src/nsStringBundle.cpp
View File

@@ -238,8 +238,11 @@ nsStringBundle::OnStreamComplete(nsIStreamLoader* aLoader,
nsXPIDLCString uriSpec;
if (NS_FAILED(aStatus)) {
if (aLoader) {
nsCOMPtr<nsIRequest> request;
nsCOMPtr<nsIChannel> channel;
aLoader->GetChannel(getter_AddRefs(channel));
aLoader->GetRequest(getter_AddRefs(request));
request = do_QueryInterface(channel);
if (channel) {
nsCOMPtr<nsIURI> uri;
channel->GetURI(getter_AddRefs(uri));

43
layout/base/nsPresShell.cpp
View File

@@ -634,13 +634,12 @@ protected:
public:
static nsresult
Create(nsIChannel** aResult, nsIPresShell* aPresShell);
Create(nsIRequest** aResult, nsIPresShell* aPresShell);
NS_DECL_ISUPPORTS
// nsIRequest
NS_IMETHOD GetName(PRUnichar* *result) {
NS_NOTREACHED("DummyLayoutRequest::GetName");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHOD IsPending(PRBool *_retval) { *_retval = PR_TRUE; return NS_OK; }
@@ -654,34 +653,22 @@ public:
NS_IMETHOD SetOriginalURI(nsIURI* aOriginalURI) { gURI = aOriginalURI; NS_ADDREF(gURI); return NS_OK; }
NS_IMETHOD GetURI(nsIURI* *aURI) { *aURI = gURI; NS_ADDREF(*aURI); return NS_OK; }
NS_IMETHOD SetURI(nsIURI* aURI) { gURI = aURI; NS_ADDREF(gURI); return NS_OK; }
NS_IMETHOD OpenInputStream(nsIInputStream **_retval) { *_retval = nsnull; return NS_OK; }
NS_IMETHOD OpenOutputStream(nsIOutputStream **_retval) { *_retval = nsnull; return NS_OK; }
NS_IMETHOD AsyncRead(nsIStreamListener *listener, nsISupports *ctxt) { return NS_OK; }
NS_IMETHOD AsyncWrite(nsIStreamProvider *provider, nsISupports *ctxt) { return NS_OK; }
NS_IMETHOD Open(nsIInputStream **_retval) { *_retval = nsnull; return NS_OK; }
NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt) { return NS_OK; }
NS_IMETHOD GetLoadAttributes(nsLoadFlags *aLoadAttributes) { *aLoadAttributes = nsIChannel::LOAD_NORMAL; return NS_OK; }
NS_IMETHOD SetLoadAttributes(nsLoadFlags aLoadAttributes) { return NS_OK; }
NS_IMETHOD GetContentType(char * *aContentType) { *aContentType = nsnull; return NS_OK; }
NS_IMETHOD SetContentType(const char *aContentType) { return NS_OK; }
NS_IMETHOD GetContentLength(PRInt32 *aContentLength) { *aContentLength = 0; return NS_OK; }
NS_IMETHOD SetContentLength(PRInt32 aContentLength) { NS_NOTREACHED("SetContentLength"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetTransferOffset(PRUint32 *aTransferOffset) { NS_NOTREACHED("GetTransferOffset"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD SetTransferOffset(PRUint32 aTransferOffset) { NS_NOTREACHED("SetTransferOffset"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetTransferCount(PRInt32 *aTransferCount) { NS_NOTREACHED("GetTransferCount"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD SetTransferCount(PRInt32 aTransferCount) { NS_NOTREACHED("SetTransferCount"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetBufferSegmentSize(PRUint32 *aBufferSegmentSize) { NS_NOTREACHED("GetBufferSegmentSize"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD SetBufferSegmentSize(PRUint32 aBufferSegmentSize) { NS_NOTREACHED("SetBufferSegmentSize"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetBufferMaxSize(PRUint32 *aBufferMaxSize) { NS_NOTREACHED("GetBufferMaxSize"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD SetBufferMaxSize(PRUint32 aBufferMaxSize) { NS_NOTREACHED("SetBufferMaxSize"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetLocalFile(nsIFile* *result) { NS_NOTREACHED("GetLocalFile"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetPipeliningAllowed(PRBool *aPipeliningAllowed) { *aPipeliningAllowed = PR_FALSE; return NS_OK; }
NS_IMETHOD SetPipeliningAllowed(PRBool aPipeliningAllowed) { NS_NOTREACHED("SetPipeliningAllowed"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetOwner(nsISupports * *aOwner) { *aOwner = nsnull; return NS_OK; }
NS_IMETHOD SetOwner(nsISupports * aOwner) { return NS_OK; }
NS_IMETHOD GetLoadGroup(nsILoadGroup * *aLoadGroup) { *aLoadGroup = mLoadGroup; NS_IF_ADDREF(*aLoadGroup); return NS_OK; }
NS_IMETHOD SetLoadGroup(nsILoadGroup * aLoadGroup) { mLoadGroup = aLoadGroup; return NS_OK; }
NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor * *aNotificationCallbacks) { *aNotificationCallbacks = nsnull; return NS_OK; }
NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor * aNotificationCallbacks) { return NS_OK; }
NS_IMETHOD GetSecurityInfo(nsISupports **info) {*info = nsnull; return NS_OK;}
NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo) { *aSecurityInfo = nsnull; return NS_OK; }
NS_IMETHOD GetContentType(char * *aContentType) { *aContentType = nsnull; return NS_OK; }
NS_IMETHOD SetContentType(const char * aContentType) { return NS_OK; }
NS_IMETHOD GetContentLength(PRInt32 *aContentLength) { return NS_OK; }
NS_IMETHOD SetContentLength(PRInt32 aContentLength) { return NS_OK; }
};
PRInt32 DummyLayoutRequest::gRefCnt;
@@ -692,7 +679,7 @@ NS_IMPL_RELEASE(DummyLayoutRequest);
NS_IMPL_QUERY_INTERFACE2(DummyLayoutRequest, nsIRequest, nsIChannel);
nsresult
DummyLayoutRequest::Create(nsIChannel** aResult, nsIPresShell* aPresShell)
DummyLayoutRequest::Create(nsIRequest** aResult, nsIPresShell* aPresShell)
{
DummyLayoutRequest* request = new DummyLayoutRequest(aPresShell);
if (!request)
@@ -1065,7 +1052,7 @@ protected:
nsCOMPtr<nsIObserverService> mObserverService; // Observer service for reflow events
nsCOMPtr<nsIDragService> mDragService;
PRInt32 mRCCreatedDuringLoad; // Counter to keep track of reflow commands created during doc
nsCOMPtr<nsIChannel> mDummyLayoutRequest;
nsCOMPtr<nsIRequest> mDummyLayoutRequest;
// used for list of posted events and attribute changes. To be done
// after reflow.
@@ -5343,10 +5330,10 @@ PresShell::AddDummyLayoutRequest(void)
}
if (loadGroup) {
rv = mDummyLayoutRequest->SetLoadGroup(loadGroup);
nsCOMPtr<nsIChannel> channel = do_QueryInterface(mDummyLayoutRequest);
rv = channel->SetLoadGroup(loadGroup);
if (NS_FAILED(rv)) return rv;
rv = loadGroup->AddChannel(mDummyLayoutRequest, nsnull);
rv = loadGroup->AddRequest(mDummyLayoutRequest, nsnull);
if (NS_FAILED(rv)) return rv;
}
@@ -5370,7 +5357,7 @@ PresShell::RemoveDummyLayoutRequest(void)
}
if (loadGroup && mDummyLayoutRequest) {
rv = loadGroup->RemoveChannel(mDummyLayoutRequest, nsnull, NS_OK, nsnull);
rv = loadGroup->RemoveRequest(mDummyLayoutRequest, nsnull, NS_OK, nsnull);
if (NS_FAILED(rv)) return rv;
mDummyLayoutRequest = nsnull;

43
layout/html/base/src/nsPresShell.cpp
View File

@@ -634,13 +634,12 @@ protected:
public:
static nsresult
Create(nsIChannel** aResult, nsIPresShell* aPresShell);
Create(nsIRequest** aResult, nsIPresShell* aPresShell);
NS_DECL_ISUPPORTS
// nsIRequest
NS_IMETHOD GetName(PRUnichar* *result) {
NS_NOTREACHED("DummyLayoutRequest::GetName");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHOD IsPending(PRBool *_retval) { *_retval = PR_TRUE; return NS_OK; }
@@ -654,34 +653,22 @@ public:
NS_IMETHOD SetOriginalURI(nsIURI* aOriginalURI) { gURI = aOriginalURI; NS_ADDREF(gURI); return NS_OK; }
NS_IMETHOD GetURI(nsIURI* *aURI) { *aURI = gURI; NS_ADDREF(*aURI); return NS_OK; }
NS_IMETHOD SetURI(nsIURI* aURI) { gURI = aURI; NS_ADDREF(gURI); return NS_OK; }
NS_IMETHOD OpenInputStream(nsIInputStream **_retval) { *_retval = nsnull; return NS_OK; }
NS_IMETHOD OpenOutputStream(nsIOutputStream **_retval) { *_retval = nsnull; return NS_OK; }
NS_IMETHOD AsyncRead(nsIStreamListener *listener, nsISupports *ctxt) { return NS_OK; }
NS_IMETHOD AsyncWrite(nsIStreamProvider *provider, nsISupports *ctxt) { return NS_OK; }
NS_IMETHOD Open(nsIInputStream **_retval) { *_retval = nsnull; return NS_OK; }
NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt) { return NS_OK; }
NS_IMETHOD GetLoadAttributes(nsLoadFlags *aLoadAttributes) { *aLoadAttributes = nsIChannel::LOAD_NORMAL; return NS_OK; }
NS_IMETHOD SetLoadAttributes(nsLoadFlags aLoadAttributes) { return NS_OK; }
NS_IMETHOD GetContentType(char * *aContentType) { *aContentType = nsnull; return NS_OK; }
NS_IMETHOD SetContentType(const char *aContentType) { return NS_OK; }
NS_IMETHOD GetContentLength(PRInt32 *aContentLength) { *aContentLength = 0; return NS_OK; }
NS_IMETHOD SetContentLength(PRInt32 aContentLength) { NS_NOTREACHED("SetContentLength"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetTransferOffset(PRUint32 *aTransferOffset) { NS_NOTREACHED("GetTransferOffset"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD SetTransferOffset(PRUint32 aTransferOffset) { NS_NOTREACHED("SetTransferOffset"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetTransferCount(PRInt32 *aTransferCount) { NS_NOTREACHED("GetTransferCount"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD SetTransferCount(PRInt32 aTransferCount) { NS_NOTREACHED("SetTransferCount"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetBufferSegmentSize(PRUint32 *aBufferSegmentSize) { NS_NOTREACHED("GetBufferSegmentSize"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD SetBufferSegmentSize(PRUint32 aBufferSegmentSize) { NS_NOTREACHED("SetBufferSegmentSize"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetBufferMaxSize(PRUint32 *aBufferMaxSize) { NS_NOTREACHED("GetBufferMaxSize"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD SetBufferMaxSize(PRUint32 aBufferMaxSize) { NS_NOTREACHED("SetBufferMaxSize"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetLocalFile(nsIFile* *result) { NS_NOTREACHED("GetLocalFile"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetPipeliningAllowed(PRBool *aPipeliningAllowed) { *aPipeliningAllowed = PR_FALSE; return NS_OK; }
NS_IMETHOD SetPipeliningAllowed(PRBool aPipeliningAllowed) { NS_NOTREACHED("SetPipeliningAllowed"); return NS_ERROR_NOT_IMPLEMENTED; }
NS_IMETHOD GetOwner(nsISupports * *aOwner) { *aOwner = nsnull; return NS_OK; }
NS_IMETHOD SetOwner(nsISupports * aOwner) { return NS_OK; }
NS_IMETHOD GetLoadGroup(nsILoadGroup * *aLoadGroup) { *aLoadGroup = mLoadGroup; NS_IF_ADDREF(*aLoadGroup); return NS_OK; }
NS_IMETHOD SetLoadGroup(nsILoadGroup * aLoadGroup) { mLoadGroup = aLoadGroup; return NS_OK; }
NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor * *aNotificationCallbacks) { *aNotificationCallbacks = nsnull; return NS_OK; }
NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor * aNotificationCallbacks) { return NS_OK; }
NS_IMETHOD GetSecurityInfo(nsISupports **info) {*info = nsnull; return NS_OK;}
NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo) { *aSecurityInfo = nsnull; return NS_OK; }
NS_IMETHOD GetContentType(char * *aContentType) { *aContentType = nsnull; return NS_OK; }
NS_IMETHOD SetContentType(const char * aContentType) { return NS_OK; }
NS_IMETHOD GetContentLength(PRInt32 *aContentLength) { return NS_OK; }
NS_IMETHOD SetContentLength(PRInt32 aContentLength) { return NS_OK; }
};
PRInt32 DummyLayoutRequest::gRefCnt;
@@ -692,7 +679,7 @@ NS_IMPL_RELEASE(DummyLayoutRequest);
NS_IMPL_QUERY_INTERFACE2(DummyLayoutRequest, nsIRequest, nsIChannel);
nsresult
DummyLayoutRequest::Create(nsIChannel** aResult, nsIPresShell* aPresShell)
DummyLayoutRequest::Create(nsIRequest** aResult, nsIPresShell* aPresShell)
{
DummyLayoutRequest* request = new DummyLayoutRequest(aPresShell);
if (!request)
@@ -1065,7 +1052,7 @@ protected:
nsCOMPtr<nsIObserverService> mObserverService; // Observer service for reflow events
nsCOMPtr<nsIDragService> mDragService;
PRInt32 mRCCreatedDuringLoad; // Counter to keep track of reflow commands created during doc
nsCOMPtr<nsIChannel> mDummyLayoutRequest;
nsCOMPtr<nsIRequest> mDummyLayoutRequest;
// used for list of posted events and attribute changes. To be done
// after reflow.
@@ -5343,10 +5330,10 @@ PresShell::AddDummyLayoutRequest(void)
}
if (loadGroup) {
rv = mDummyLayoutRequest->SetLoadGroup(loadGroup);
nsCOMPtr<nsIChannel> channel = do_QueryInterface(mDummyLayoutRequest);
rv = channel->SetLoadGroup(loadGroup);
if (NS_FAILED(rv)) return rv;
rv = loadGroup->AddChannel(mDummyLayoutRequest, nsnull);
rv = loadGroup->AddRequest(mDummyLayoutRequest, nsnull);
if (NS_FAILED(rv)) return rv;
}
@@ -5370,7 +5357,7 @@ PresShell::RemoveDummyLayoutRequest(void)
}
if (loadGroup && mDummyLayoutRequest) {
rv = loadGroup->RemoveChannel(mDummyLayoutRequest, nsnull, NS_OK, nsnull);
rv = loadGroup->RemoveRequest(mDummyLayoutRequest, nsnull, NS_OK, nsnull);
if (NS_FAILED(rv)) return rv;
mDummyLayoutRequest = nsnull;

8
layout/html/document/src/nsHTMLContentSink.cpp
View File

@@ -4715,8 +4715,12 @@ HTMLContentSink::OnStreamComplete(nsIStreamLoader* aLoader,
nsCOMPtr<nsIHTTPChannel> httpChannel;
nsCOMPtr<nsIChannel> channel;
rv = aLoader->GetChannel(getter_AddRefs(channel));
NS_ASSERTION(channel, "StreamLoader's channel went away prematurely");
nsCOMPtr<nsIRequest> request;
rv = aLoader->GetRequest(getter_AddRefs(request));
NS_ASSERTION(request, "StreamLoader's request went away prematurely");
if (NS_FAILED(rv)) return rv;
channel = do_QueryInterface(request);
if (channel) {
httpChannel = do_QueryInterface(channel);

10
layout/html/document/src/nsHTMLDocument.cpp
View File

@@ -585,7 +585,8 @@ nsHTMLDocument::StartDocumentLoad(const char* aCommand,
nsCOMPtr<nsIFile> file;
rv = fileChannel->GetFile(getter_AddRefs(file));
if (NS_FAILED(rv)) { return rv; }
if (NS_SUCCEEDED(rv))
{
// if we failed to get a last modification date, then we don't want to necessarily
// fail to create a document for this file. Just don't set the last modified date on it...
rv = file->GetLastModificationDate(&modDate);
@@ -603,16 +604,17 @@ nsHTMLDocument::StartDocumentLoad(const char* aCommand,
// non-y2k with msvc; '%#c' requests that a full year be used in the
// result string. Other OSes just use "%c".
PR_FormatTime(buf, sizeof buf,
#if defined(XP_PC) && !defined(XP_OS2)
#if defined(XP_PC) && !defined(XP_OS2)
"%#c",
#else
#else
"%c",
#endif
#endif
&prtime);
lastModified.AssignWithConversion(buf);
SetLastModified(lastModified);
}
}
}
static NS_DEFINE_IID(kCParserCID, NS_PARSER_IID);

16
layout/html/document/src/nsImageDocument.cpp
View File

@@ -121,10 +121,14 @@ ImageListener::~ImageListener()
NS_IMPL_THREADSAFE_ISUPPORTS(ImageListener, NS_GET_IID(nsIStreamListener))
NS_IMETHODIMP
ImageListener::OnStartRequest(nsIChannel* channel, nsISupports *ctxt)
ImageListener::OnStartRequest(nsIRequest* request, nsISupports *ctxt)
{
nsresult rv;
nsIURI* uri;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (!channel) return NS_ERROR_NULL_POINTER;
rv = channel->GetURI(&uri);
if (NS_FAILED(rv)) return rv;
@@ -133,11 +137,11 @@ ImageListener::OnStartRequest(nsIChannel* channel, nsISupports *ctxt)
if (nsnull == mNextStream) {
return NS_ERROR_FAILURE;
}
return mNextStream->OnStartRequest(channel, ctxt);
return mNextStream->OnStartRequest(request, ctxt);
}
NS_IMETHODIMP
ImageListener::OnStopRequest(nsIChannel* channel, nsISupports *ctxt,
ImageListener::OnStopRequest(nsIRequest* request, nsISupports *ctxt,
nsresult status, const PRUnichar *errorMsg)
{
if(mDocument){
@@ -147,17 +151,17 @@ ImageListener::OnStopRequest(nsIChannel* channel, nsISupports *ctxt,
if (nsnull == mNextStream) {
return NS_ERROR_FAILURE;
}
return mNextStream->OnStopRequest(channel, ctxt, status, errorMsg);
return mNextStream->OnStopRequest(request, ctxt, status, errorMsg);
}
NS_IMETHODIMP
ImageListener::OnDataAvailable(nsIChannel* channel, nsISupports *ctxt,
ImageListener::OnDataAvailable(nsIRequest* request, nsISupports *ctxt,
nsIInputStream *inStr, PRUint32 sourceOffset, PRUint32 count)
{
if (nsnull == mNextStream) {
return NS_ERROR_FAILURE;
}
return mNextStream->OnDataAvailable(channel, ctxt, inStr, sourceOffset, count);
return mNextStream->OnDataAvailable(request, ctxt, inStr, sourceOffset, count);
}
//----------------------------------------------------------------------

33
layout/xbl/src/nsXBLService.cpp
View File

@@ -260,37 +260,36 @@ nsXBLStreamListener::~nsXBLStreamListener()
}
}
/* void onDataAvailable (in nsIChannel channel, in nsISupports ctxt, in nsIInputStream inStr, in unsigned long sourceOffset, in unsigned long count); */
NS_IMETHODIMP
nsXBLStreamListener::OnDataAvailable(nsIChannel* aChannel, nsISupports* aCtxt, nsIInputStream* aInStr,
nsXBLStreamListener::OnDataAvailable(nsIRequest *request, nsISupports* aCtxt, nsIInputStream* aInStr,
PRUint32 aSourceOffset, PRUint32 aCount)
{
if (mInner)
return mInner->OnDataAvailable(aChannel, aCtxt, aInStr, aSourceOffset, aCount);
return mInner->OnDataAvailable(request, aCtxt, aInStr, aSourceOffset, aCount);
return NS_ERROR_FAILURE;
}
/* void onStartRequest (in nsIChannel channel, in nsISupports ctxt); */
NS_IMETHODIMP
nsXBLStreamListener::OnStartRequest(nsIChannel* aChannel, nsISupports* aCtxt)
nsXBLStreamListener::OnStartRequest(nsIRequest* request, nsISupports* aCtxt)
{
if (mInner)
return mInner->OnStartRequest(aChannel, aCtxt);
return mInner->OnStartRequest(request, aCtxt);
return NS_ERROR_FAILURE;
}
/* void onStopRequest (in nsIChannel channel, in nsISupports ctxt, in nsresult status, in wstring statusArg); */
NS_IMETHODIMP
nsXBLStreamListener::OnStopRequest(nsIChannel* aChannel, nsISupports* aCtxt, nsresult aStatus, const PRUnichar* aStatusArg)
nsXBLStreamListener::OnStopRequest(nsIRequest* request, nsISupports* aCtxt, nsresult aStatus, const PRUnichar* aStatusArg)
{
nsresult rv = NS_OK;
if (mInner) {
rv = mInner->OnStopRequest(aChannel, aCtxt, aStatus, aStatusArg);
rv = mInner->OnStopRequest(request, aCtxt, aStatus, aStatusArg);
}
if (NS_FAILED(rv) || NS_FAILED(aStatus))
{
nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
if (aChannel)
{
nsCOMPtr<nsIURI> channelURI;
@@ -1191,7 +1190,7 @@ nsXBLService::FetchBindingDocument(nsIContent* aBoundElement, nsIDocument* aBoun
nsCOMPtr<nsILoadGroup> loadGroup;
if (aBoundDocument)
aBoundDocument->GetDocumentLoadGroup(getter_AddRefs(loadGroup));
nsCOMPtr<nsIRequest> request;
nsCOMPtr<nsIChannel> channel;
rv = NS_OpenURI(getter_AddRefs(channel), aURI, nsnull, loadGroup);
if (NS_FAILED(rv)) return rv;
@@ -1233,18 +1232,22 @@ nsXBLService::FetchBindingDocument(nsIContent* aBoundElement, nsIDocument* aBoun
xblListener->AddRequest(req);
// Now kick off the async read.
channel->AsyncRead(xblListener, nsnull);
channel->AsyncOpen(xblListener, nsnull);
return NS_OK;
}
// Now do a blocking synchronous parse of the file.
nsCOMPtr<nsIInputStream> in;
PRUint32 sourceOffset = 0;
rv = channel->OpenInputStream(getter_AddRefs(in));
rv = channel->Open(getter_AddRefs(in));
// If we couldn't open the channel, then just return.
if (NS_FAILED(rv)) return NS_OK;
request = do_QueryInterface(channel);
NS_ASSERTION(request != nsnull, "no request info");
NS_ASSERTION(in != nsnull, "no input stream");
if (! in) return NS_ERROR_FAILURE;
@@ -1253,7 +1256,7 @@ nsXBLService::FetchBindingDocument(nsIContent* aBoundElement, nsIDocument* aBoun
if (! proxy)
return NS_ERROR_FAILURE;
listener->OnStartRequest(channel, nsnull);
listener->OnStartRequest(request, nsnull);
while (PR_TRUE) {
char buf[1024];
PRUint32 readCount;
@@ -1266,12 +1269,12 @@ nsXBLService::FetchBindingDocument(nsIContent* aBoundElement, nsIDocument* aBoun
proxy->SetBuffer(buf, readCount);
rv = listener->OnDataAvailable(channel, nsnull, proxy, sourceOffset, readCount);
rv = listener->OnDataAvailable(request, nsnull, proxy, sourceOffset, readCount);
sourceOffset += readCount;
if (NS_FAILED(rv))
break;
}
listener->OnStopRequest(channel, nsnull, NS_OK, nsnull);
listener->OnStopRequest(request, nsnull, NS_OK, nsnull);
// don't leak proxy!
proxy->Close();

6
layout/xml/document/src/nsXMLContentSink.cpp
View File

@@ -1669,7 +1669,11 @@ nsXMLContentSink::OnStreamComplete(nsIStreamLoader* aLoader,
if (NS_OK == aStatus) {
{ // scope in block so nsCOMPtr released at one point
nsCOMPtr<nsIChannel> channel;
aLoader->GetChannel(getter_AddRefs(channel));
nsCOMPtr<nsIRequest> request;
aLoader->GetRequest(getter_AddRefs(request));
if (request)
channel = do_QueryInterface(request);
nsCOMPtr<nsIURI> url;
if (channel) {
channel->GetURI(getter_AddRefs(url));

11
layout/xml/document/src/nsXMLDocument.cpp
View File

@@ -74,6 +74,11 @@
#include "nsIPrincipal.h"
#include "nsIAggregatePrincipal.h"
#include "nsCExternalHandlerService.h"
#include "nsIMIMEService.h"
#include "nsNetUtil.h"
#include "nsMimeTypes.h"
// XXX The XML world depends on the html atoms
#include "nsHTMLAtoms.h"
@@ -351,7 +356,7 @@ nsXMLDocument::Load(const nsAReadableString& aUrl)
}
// Start an asynchronous read of the XML document
rv = channel->AsyncRead(listener, nsnull);
rv = channel->AsyncOpen(listener, nsnull);
return rv;
}
@@ -381,7 +386,9 @@ nsXMLDocument::StartDocumentLoad(const char* aCommand,
rv = aChannel->GetURI(getter_AddRefs(aUrl));
if (NS_FAILED(rv)) return rv;
rv = aChannel->GetContentType(&aContentType);
nsCOMPtr<nsIMIMEService> MIMEService (do_GetService(NS_MIMESERVICE_CONTRACTID, &rv));
if (NS_FAILED(rv)) return rv;
rv = MIMEService->GetTypeFromURI(aUrl, &aContentType);
if (NS_SUCCEEDED(rv)) {
if ( 0 == PL_strcmp(aContentType, "text/html")) {

2
layout/xml/document/src/nsXMLDocument.h
View File

@@ -52,7 +52,7 @@ public:
NS_IMETHOD GetContentType(nsAWritableString& aContentType) const;
NS_IMETHOD StartDocumentLoad(const char* aCommand,
nsIChannel* aChannel,
nsIChannel* channel,
nsILoadGroup* aLoadGroup,
nsISupports* aContainer,
nsIStreamListener **aDocListener,

143
modules/libjar/nsJARChannel.cpp
View File

@@ -31,6 +31,7 @@
#include "nsMimeTypes.h"
#include "nsScriptSecurityManager.h"
#include "nsIAggregatePrincipal.h"
#include "nsIProgressEventSink.h"
#include "nsXPIDLString.h"
static NS_DEFINE_CID(kFileTransportServiceCID, NS_FILETRANSPORTSERVICE_CID);
@@ -60,13 +61,9 @@ PRLogModuleInfo* gJarProtocolLog = nsnull;
nsJARChannel::nsJARChannel()
: mLoadAttributes(LOAD_NORMAL),
mStartPosition(0),
mReadCount(-1),
mContentType(nsnull),
mContentLength(-1),
mJAREntry(nsnull),
mBufferSegmentSize(NS_DEFAULT_JAR_BUFFER_SEGMENT_SIZE),
mBufferMaxSize(NS_DEFAULT_JAR_BUFFER_MAX_SIZE),
mStatus(NS_OK),
mMonitor(nsnull)
{
@@ -255,12 +252,12 @@ nsJARChannel::OpenJARElement()
rv = Open(nsnull, nsnull);
if (NS_SUCCEEDED(rv))
rv = GetInputStream(getter_AddRefs(mSynchronousInputStream));
mon.Notify(); // wake up OpenInputStream
mon.Notify(); // wake up nsIChannel::Open
return rv;
}
NS_IMETHODIMP
nsJARChannel::OpenInputStream(nsIInputStream* *result)
nsJARChannel::Open(nsIInputStream* *result)
{
nsAutoCMonitor mon(this);
nsresult rv;
@@ -273,7 +270,7 @@ nsJARChannel::OpenInputStream(nsIInputStream* *result)
{
*result = mSynchronousInputStream; // Result of GetInputStream called on transport thread
NS_ADDREF(*result);
mSynchronousInputStream = null_nsCOMPtr();
mSynchronousInputStream = 0;
return NS_OK;
}
else
@@ -281,14 +278,7 @@ nsJARChannel::OpenInputStream(nsIInputStream* *result)
}
NS_IMETHODIMP
nsJARChannel::OpenOutputStream(nsIOutputStream* *result)
{
NS_NOTREACHED("nsJARChannel::OpenOutputStream");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsJARChannel::AsyncRead(nsIStreamListener* listener, nsISupports* ctxt)
nsJARChannel::AsyncOpen(nsIStreamListener* listener, nsISupports* ctxt)
{
nsresult rv;
mUserContext = ctxt;
@@ -310,7 +300,7 @@ nsJARChannel::AsyncRead(nsIStreamListener* listener, nsISupports* ctxt)
}
}
}
rv = mLoadGroup->AddChannel(this, nsnull);
rv = mLoadGroup->AddRequest(this, nsnull);
if (NS_FAILED(rv)) return rv;
}
@@ -342,7 +332,7 @@ nsJARChannel::EnsureJARFileAvailable()
rv = NS_NewDownloader(getter_AddRefs(mDownloader),
mJARBaseURI, this, nsnull, mSynchronousRead, mLoadGroup, mCallbacks,
mLoadAttributes, mBufferSegmentSize, mBufferMaxSize);
mLoadAttributes);
// if DownloadComplete() was called early, need to release the reference.
if (mSynchronousRead && mSynchronousInputStream)
@@ -350,7 +340,7 @@ nsJARChannel::EnsureJARFileAvailable()
error:
if (NS_FAILED(rv) && mLoadGroup) {
nsresult rv2 = mLoadGroup->RemoveChannel(this, nsnull, NS_OK, nsnull);
nsresult rv2 = mLoadGroup->RemoveRequest(this, nsnull, NS_OK, nsnull);
NS_ASSERTION(NS_SUCCEEDED(rv2), "RemoveChannel failed");
}
return rv;
@@ -366,20 +356,16 @@ nsJARChannel::AsyncReadJARElement()
NS_WITH_SERVICE(nsIFileTransportService, fts, kFileTransportServiceCID, &rv);
if (NS_FAILED(rv)) return rv;
rv = fts->CreateTransportFromStreamIO(this,
getter_AddRefs(mJarExtractionTransport));
if (NS_FAILED(rv)) return rv;
rv = mJarExtractionTransport->SetBufferSegmentSize(mBufferSegmentSize);
if (NS_FAILED(rv)) return rv;
rv = mJarExtractionTransport->SetBufferMaxSize(mBufferMaxSize);
if (NS_FAILED(rv)) return rv;
rv = mJarExtractionTransport->SetNotificationCallbacks(mCallbacks);
if (NS_FAILED(rv)) return rv;
rv = mJarExtractionTransport->SetTransferOffset(mStartPosition);
if (NS_FAILED(rv)) return rv;
rv = mJarExtractionTransport->SetTransferCount(mReadCount);
nsCOMPtr<nsITransport> jarTransport;
rv = fts->CreateTransportFromStreamIO(this, getter_AddRefs(jarTransport));
if (NS_FAILED(rv)) return rv;
if (mCallbacks) {
nsCOMPtr<nsIProgressEventSink> sink = do_GetInterface(mCallbacks);
if (sink)
jarTransport->SetProgressEventSink(sink);
}
#ifdef PR_LOGGING
nsXPIDLCString jarURLStr;
mURI->GetSpec(getter_Copies(jarURLStr));
@@ -387,18 +373,10 @@ nsJARChannel::AsyncReadJARElement()
("nsJarProtocol: AsyncRead jar entry %s", (const char*)jarURLStr));
#endif
rv = mJarExtractionTransport->AsyncRead(this, nsnull);
rv = jarTransport->AsyncRead(this, nsnull, 0, -1, 0, getter_AddRefs(mJarExtractionTransport));
return rv;
}
NS_IMETHODIMP
nsJARChannel::AsyncWrite(nsIStreamProvider* provider,
nsISupports* ctxt)
{
NS_NOTREACHED("nsJARChannel::AsyncWrite");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsJARChannel::GetLoadAttributes(PRUint32* aLoadFlags)
{
@@ -491,83 +469,6 @@ nsJARChannel::SetContentLength(PRInt32 aContentLength)
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsJARChannel::GetTransferOffset(PRUint32 *aTransferOffset)
{
*aTransferOffset = mStartPosition;
return NS_OK;
}
NS_IMETHODIMP
nsJARChannel::SetTransferOffset(PRUint32 aTransferOffset)
{
mStartPosition = aTransferOffset;
return NS_OK;
}
NS_IMETHODIMP
nsJARChannel::GetTransferCount(PRInt32 *aTransferCount)
{
*aTransferCount = mReadCount;
return NS_OK;
}
NS_IMETHODIMP
nsJARChannel::SetTransferCount(PRInt32 aTransferCount)
{
mReadCount = aTransferCount;
return NS_OK;
}
NS_IMETHODIMP
nsJARChannel::GetBufferSegmentSize(PRUint32 *aBufferSegmentSize)
{
*aBufferSegmentSize = mBufferSegmentSize;
return NS_OK;
}
NS_IMETHODIMP
nsJARChannel::SetBufferSegmentSize(PRUint32 aBufferSegmentSize)
{
mBufferSegmentSize = aBufferSegmentSize;
return NS_OK;
}
NS_IMETHODIMP
nsJARChannel::GetBufferMaxSize(PRUint32 *aBufferMaxSize)
{
*aBufferMaxSize = mBufferMaxSize;
return NS_OK;
}
NS_IMETHODIMP
nsJARChannel::SetBufferMaxSize(PRUint32 aBufferMaxSize)
{
mBufferMaxSize = aBufferMaxSize;
return NS_OK;
}
NS_IMETHODIMP
nsJARChannel::GetLocalFile(nsIFile* *file)
{
*file = nsnull;
return NS_OK;
}
NS_IMETHODIMP
nsJARChannel::GetPipeliningAllowed(PRBool *aPipeliningAllowed)
{
*aPipeliningAllowed = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP
nsJARChannel::SetPipeliningAllowed(PRBool aPipeliningAllowed)
{
NS_NOTREACHED("SetPipeliningAllowed");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsJARChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
{
@@ -667,7 +568,7 @@ nsJARChannel::OnDownloadComplete(nsIDownloader* aDownloader, nsISupports* aClosu
else
rv = AsyncReadJARElement();
}
mDownloader = null_nsCOMPtr();
mDownloader = 0;
return rv;
}
@@ -675,14 +576,14 @@ nsJARChannel::OnDownloadComplete(nsIDownloader* aDownloader, nsISupports* aClosu
// nsIStreamObserver methods:
NS_IMETHODIMP
nsJARChannel::OnStartRequest(nsIChannel* jarExtractionTransport,
nsJARChannel::OnStartRequest(nsIRequest* jarExtractionTransport,
nsISupports* context)
{
return mUserListener->OnStartRequest(this, mUserContext);
}
NS_IMETHODIMP
nsJARChannel::OnStopRequest(nsIChannel* jarExtractionTransport, nsISupports* context,
nsJARChannel::OnStopRequest(nsIRequest* jarExtractionTransport, nsISupports* context,
nsresult aStatus, const PRUnichar* aStatusArg)
{
nsresult rv;
@@ -701,7 +602,7 @@ nsJARChannel::OnStopRequest(nsIChannel* jarExtractionTransport, nsISupports* con
if (mLoadGroup) {
if (NS_SUCCEEDED(rv)) {
mLoadGroup->RemoveChannel(this, context, aStatus, aStatusArg);
mLoadGroup->RemoveRequest(this, context, aStatus, aStatusArg);
}
}
@@ -715,7 +616,7 @@ nsJARChannel::OnStopRequest(nsIChannel* jarExtractionTransport, nsISupports* con
// nsIStreamListener methods:
NS_IMETHODIMP
nsJARChannel::OnDataAvailable(nsIChannel* jarCacheTransport,
nsJARChannel::OnDataAvailable(nsIRequest* jarCacheTransport,
nsISupports* context,
nsIInputStream *inStr,
PRUint32 sourceOffset,

6
modules/libjar/nsJARChannel.h
View File

@@ -89,8 +89,6 @@ protected:
nsLoadFlags mLoadAttributes;
nsCOMPtr<nsISupports> mOwner;
PRUint32 mStartPosition;
PRInt32 mReadCount;
nsCOMPtr<nsISupports> mUserContext;
nsCOMPtr<nsIStreamListener> mUserListener;
@@ -100,15 +98,13 @@ protected:
char* mJAREntry;
nsCOMPtr<nsIZipReader> mJAR;
nsCOMPtr<nsIFile> mDownloadedJARFile;
PRUint32 mBufferSegmentSize;
PRUint32 mBufferMaxSize;
nsresult mStatus;
PRBool mSynchronousRead;
nsCOMPtr<nsIInputStream> mSynchronousInputStream;
PRMonitor* mMonitor;
nsCOMPtr<nsIDownloader> mDownloader;
nsCOMPtr<nsIChannel> mJarExtractionTransport;
nsCOMPtr<nsIRequest> mJarExtractionTransport;
};

47
modules/plugin/base/src/nsPluginHostImpl.cpp
View File

@@ -953,7 +953,7 @@ public:
private:
nsresult SetUpCache(nsIURI* aURL);
nsresult SetUpStreamListener(nsIChannel *channel, nsIURI* aURL);
nsresult SetUpStreamListener(nsIRequest* request, nsIURI* aURL);
nsIURI *mURL;
nsIPluginInstanceOwner *mOwner;
@@ -1014,13 +1014,13 @@ nsPluginCacheListener::~nsPluginCacheListener()
NS_IMPL_ISUPPORTS(nsPluginCacheListener, kIStreamListenerIID);
NS_IMETHODIMP
nsPluginCacheListener::OnStartRequest(nsIChannel* channel, nsISupports* ctxt)
nsPluginCacheListener::OnStartRequest(nsIRequest *request, nsISupports* ctxt)
{
return NS_OK;
}
NS_IMETHODIMP
nsPluginCacheListener::OnDataAvailable(nsIChannel* channel, nsISupports* ctxt,
nsPluginCacheListener::OnDataAvailable(nsIRequest *request, nsISupports* ctxt,
nsIInputStream* aIStream,
PRUint32 sourceOffset,
PRUint32 aLength)
@@ -1043,7 +1043,7 @@ nsPluginCacheListener::OnDataAvailable(nsIChannel* channel, nsISupports* ctxt,
}
NS_IMETHODIMP
nsPluginCacheListener::OnStopRequest(nsIChannel* channel,
nsPluginCacheListener::OnStopRequest(nsIRequest *request,
nsISupports* aContext,
nsresult aStatus,
const PRUnichar* aMsg)
@@ -1211,10 +1211,15 @@ nsresult nsPluginStreamListenerPeer::InitializeFullPage(nsIPluginInstance *aInst
NS_IMETHODIMP
nsPluginStreamListenerPeer::OnStartRequest(nsIChannel* channel, nsISupports* aContext)
nsPluginStreamListenerPeer::OnStartRequest(nsIRequest *request, nsISupports* aContext)
{
nsresult rv = NS_OK;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (!channel)
return NS_ERROR_FAILURE;
char* aContentType = nsnull;
rv = channel->GetContentType(&aContentType);
if (NS_FAILED(rv)) return rv;
@@ -1287,14 +1292,14 @@ nsPluginStreamListenerPeer::OnStartRequest(nsIChannel* channel, nsISupports* aCo
}
rv = SetUpStreamListener(channel, aURL);
rv = SetUpStreamListener(request, aURL);
if (NS_FAILED(rv)) return rv;
return rv;
}
NS_IMETHODIMP nsPluginStreamListenerPeer::OnProgress(nsIChannel* channel,
NS_IMETHODIMP nsPluginStreamListenerPeer::OnProgress(nsIRequest *request,
nsISupports* aContext,
PRUint32 aProgress,
PRUint32 aProgressMax)
@@ -1303,7 +1308,7 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnProgress(nsIChannel* channel,
return rv;
}
NS_IMETHODIMP nsPluginStreamListenerPeer::OnStatus(nsIChannel* channel,
NS_IMETHODIMP nsPluginStreamListenerPeer::OnStatus(nsIRequest *request,
nsISupports* aContext,
nsresult aStatus,
const PRUnichar* aStatusArg)
@@ -1311,7 +1316,7 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnStatus(nsIChannel* channel,
return NS_OK;
}
NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIChannel* channel,
NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIRequest *request,
nsISupports* aContext,
nsIInputStream *aIStream,
PRUint32 sourceOffset,
@@ -1319,6 +1324,9 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIChannel* channel,
{
nsresult rv = NS_OK;
nsCOMPtr<nsIURI> aURL;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (!channel) return NS_ERROR_FAILURE;
rv = channel->GetURI(getter_AddRefs(aURL));
if (NS_FAILED(rv)) return rv;
@@ -1340,7 +1348,7 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIChannel* channel,
// if a plugin returns an error, the peer must kill the stream
// else the stream and PluginStreamListener leak
if (NS_FAILED(rv))
channel->Cancel(rv);
request->Cancel(rv);
}
else
{
@@ -1353,13 +1361,15 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIChannel* channel,
return rv;
}
NS_IMETHODIMP nsPluginStreamListenerPeer::OnStopRequest(nsIChannel* channel,
NS_IMETHODIMP nsPluginStreamListenerPeer::OnStopRequest(nsIRequest *request,
nsISupports* aContext,
nsresult aStatus,
const PRUnichar* aMsg)
{
nsresult rv = NS_OK;
nsCOMPtr<nsIURI> aURL;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (!channel) return NS_ERROR_FAILURE;
rv = channel->GetURI(getter_AddRefs(aURL));
if (NS_FAILED(rv)) return rv;
@@ -1367,7 +1377,11 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnStopRequest(nsIChannel* channel,
{
char* urlString;
nsCOMPtr<nsIFile> localFile;
rv = channel->GetLocalFile(getter_AddRefs(localFile));
nsCOMPtr<nsIFileChannel> fileChannel = do_QueryInterface(channel);
if (fileChannel)
rv = fileChannel->GetFile(getter_AddRefs(localFile));
if (NS_SUCCEEDED(rv) && localFile)
{
char* pathAndFilename;
@@ -1422,7 +1436,7 @@ nsresult nsPluginStreamListenerPeer::SetUpCache(nsIURI* aURL)
return NS_OpenURI(cacheListener, nsnull, aURL, nsnull);
}
nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIChannel* channel,
nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIRequest *request,
nsIURI* aURL)
{
nsresult rv = NS_OK;
@@ -1454,6 +1468,8 @@ nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIChannel* channel,
nsCOMPtr<nsIHTTPHeaderListener> headerListener =
do_QueryInterface(mPStreamListener);
if (headerListener) {
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
nsCOMPtr<nsIHTTPChannel> httpChannel = do_QueryInterface(channel);
if (httpChannel) {
ReadHeadersFromChannelAndPostToListener(httpChannel, headerListener);
@@ -1465,6 +1481,8 @@ nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIChannel* channel,
mPluginStreamInfo->SetSeekable(PR_FALSE);
// get Last-Modified header for plugin info
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
nsCOMPtr<nsIHTTPChannel> theHTTPChannel = do_QueryInterface(channel);
if (theHTTPChannel) {
char * lastModified;
@@ -3806,8 +3824,7 @@ NS_IMETHODIMP nsPluginHostImpl::NewPluginURLStream(const nsString& aURL,
}
}
rv = channel->AsyncRead(listenerPeer, nsnull);
rv = channel->AsyncOpen(listenerPeer, nsnull);
}
NS_RELEASE(listenerPeer);

1
modules/plugin/base/src/nsPluginHostImpl.h
View File

@@ -37,6 +37,7 @@ class ns4xPlugin;
class nsFileSpec;
class nsIComponentManager;
class nsIFile;
class nsIChannel;
/**
* A linked-list of plugin information that is used for

35
modules/plugin/base/src/nsPluginViewer.cpp
View File

@@ -157,14 +157,14 @@ public:
virtual ~PluginViewerImpl();
nsresult CreatePlugin(nsIPluginHost* aHost, const nsRect& aBounds,
nsresult CreatePlugin(nsIRequest* request, nsIPluginHost* aHost, const nsRect& aBounds,
nsIStreamListener*& aResult);
nsresult MakeWindow(nsNativeWidget aParent,
nsIDeviceContext* aDeviceContext,
const nsRect& aBounds);
nsresult StartLoad(nsIChannel* channel, nsIStreamListener*& aResult);
nsresult StartLoad(nsIRequest* request, nsIStreamListener*& aResult);
void ForceRefresh(void);
@@ -307,15 +307,18 @@ PluginViewerImpl::Init(nsIWidget* aParentWidget,
}
nsresult
PluginViewerImpl::StartLoad(nsIChannel* channel, nsIStreamListener*& aResult)
PluginViewerImpl::StartLoad(nsIRequest* request, nsIStreamListener*& aResult)
{
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (!channel) return NS_ERROR_FAILURE;
NS_IF_RELEASE(mChannel);
mChannel = channel;
NS_ADDREF(mChannel);
#ifdef DEBUG
char* contentType;
mChannel->GetContentType(&contentType);
channel->GetContentType(&contentType);
printf("PluginViewerImpl::StartLoad: content-type=%s\n", contentType);
nsCRT::free(contentType);
#endif
@@ -331,14 +334,14 @@ PluginViewerImpl::StartLoad(nsIChannel* channel, nsIStreamListener*& aResult)
{
nsRect r;
mWindow->GetClientBounds(r);
rv = CreatePlugin(host, nsRect(0, 0, r.width, r.height), aResult);
rv = CreatePlugin(request, host, nsRect(0, 0, r.width, r.height), aResult);
}
return rv;
}
nsresult
PluginViewerImpl::CreatePlugin(nsIPluginHost* aHost, const nsRect& aBounds,
PluginViewerImpl::CreatePlugin(nsIRequest* request, nsIPluginHost* aHost, const nsRect& aBounds,
nsIStreamListener*& aResult)
{
nsresult rv = NS_OK;
@@ -372,7 +375,9 @@ PluginViewerImpl::CreatePlugin(nsIPluginHost* aHost, const nsRect& aBounds,
nsCRT::free(spec);
char* ct;
rv = mChannel->GetContentType(&ct);
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
channel->GetContentType(&ct);
if (NS_FAILED(rv)) return rv;
rv = aHost->InstantiateFullPagePlugin(ct, str, aResult, mOwner);
delete[] ct;
@@ -692,43 +697,45 @@ PluginListener::~PluginListener()
NS_IMPL_ISUPPORTS(PluginListener, kIStreamListenerIID)
NS_IMETHODIMP
PluginListener::OnStartRequest(nsIChannel* channel, nsISupports *ctxt)
PluginListener::OnStartRequest(nsIRequest *request, nsISupports *ctxt)
{
nsresult rv;
char* contentType = nsnull;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
rv = channel->GetContentType(&contentType);
if (NS_FAILED(rv)) {
return rv;
}
rv = mViewer->StartLoad(channel, mNextStream);
rv = mViewer->StartLoad(request, mNextStream);
if (NS_FAILED(rv)) {
return rv;
}
if (nsnull == mNextStream)
return NS_ERROR_FAILURE;
return mNextStream->OnStartRequest(channel, ctxt);
return mNextStream->OnStartRequest(request, ctxt);
}
NS_IMETHODIMP
PluginListener::OnStopRequest(nsIChannel* channel, nsISupports *ctxt,
PluginListener::OnStopRequest(nsIRequest *request, nsISupports *ctxt,
nsresult status, const PRUnichar *errorMsg)
{
if (nsnull == mNextStream) {
return NS_ERROR_FAILURE;
}
return mNextStream->OnStopRequest(channel, ctxt, status, errorMsg);
return mNextStream->OnStopRequest(request, ctxt, status, errorMsg);
}
NS_IMETHODIMP
PluginListener::OnDataAvailable(nsIChannel* channel, nsISupports *ctxt,
PluginListener::OnDataAvailable(nsIRequest *request, nsISupports *ctxt,
nsIInputStream *inStr, PRUint32 sourceOffset, PRUint32 count)
{
if (nsnull == mNextStream) {
return NS_ERROR_FAILURE;
}
return mNextStream->OnDataAvailable(channel, ctxt, inStr, sourceOffset, count);
return mNextStream->OnDataAvailable(request, ctxt, inStr, sourceOffset, count);
}
//----------------------------------------------------------------------

47
modules/plugin/nglsrc/nsPluginHostImpl.cpp
View File

@@ -953,7 +953,7 @@ public:
private:
nsresult SetUpCache(nsIURI* aURL);
nsresult SetUpStreamListener(nsIChannel *channel, nsIURI* aURL);
nsresult SetUpStreamListener(nsIRequest* request, nsIURI* aURL);
nsIURI *mURL;
nsIPluginInstanceOwner *mOwner;
@@ -1014,13 +1014,13 @@ nsPluginCacheListener::~nsPluginCacheListener()
NS_IMPL_ISUPPORTS(nsPluginCacheListener, kIStreamListenerIID);
NS_IMETHODIMP
nsPluginCacheListener::OnStartRequest(nsIChannel* channel, nsISupports* ctxt)
nsPluginCacheListener::OnStartRequest(nsIRequest *request, nsISupports* ctxt)
{
return NS_OK;
}
NS_IMETHODIMP
nsPluginCacheListener::OnDataAvailable(nsIChannel* channel, nsISupports* ctxt,
nsPluginCacheListener::OnDataAvailable(nsIRequest *request, nsISupports* ctxt,
nsIInputStream* aIStream,
PRUint32 sourceOffset,
PRUint32 aLength)
@@ -1043,7 +1043,7 @@ nsPluginCacheListener::OnDataAvailable(nsIChannel* channel, nsISupports* ctxt,
}
NS_IMETHODIMP
nsPluginCacheListener::OnStopRequest(nsIChannel* channel,
nsPluginCacheListener::OnStopRequest(nsIRequest *request,
nsISupports* aContext,
nsresult aStatus,
const PRUnichar* aMsg)
@@ -1211,10 +1211,15 @@ nsresult nsPluginStreamListenerPeer::InitializeFullPage(nsIPluginInstance *aInst
NS_IMETHODIMP
nsPluginStreamListenerPeer::OnStartRequest(nsIChannel* channel, nsISupports* aContext)
nsPluginStreamListenerPeer::OnStartRequest(nsIRequest *request, nsISupports* aContext)
{
nsresult rv = NS_OK;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (!channel)
return NS_ERROR_FAILURE;
char* aContentType = nsnull;
rv = channel->GetContentType(&aContentType);
if (NS_FAILED(rv)) return rv;
@@ -1287,14 +1292,14 @@ nsPluginStreamListenerPeer::OnStartRequest(nsIChannel* channel, nsISupports* aCo
}
rv = SetUpStreamListener(channel, aURL);
rv = SetUpStreamListener(request, aURL);
if (NS_FAILED(rv)) return rv;
return rv;
}
NS_IMETHODIMP nsPluginStreamListenerPeer::OnProgress(nsIChannel* channel,
NS_IMETHODIMP nsPluginStreamListenerPeer::OnProgress(nsIRequest *request,
nsISupports* aContext,
PRUint32 aProgress,
PRUint32 aProgressMax)
@@ -1303,7 +1308,7 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnProgress(nsIChannel* channel,
return rv;
}
NS_IMETHODIMP nsPluginStreamListenerPeer::OnStatus(nsIChannel* channel,
NS_IMETHODIMP nsPluginStreamListenerPeer::OnStatus(nsIRequest *request,
nsISupports* aContext,
nsresult aStatus,
const PRUnichar* aStatusArg)
@@ -1311,7 +1316,7 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnStatus(nsIChannel* channel,
return NS_OK;
}
NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIChannel* channel,
NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIRequest *request,
nsISupports* aContext,
nsIInputStream *aIStream,
PRUint32 sourceOffset,
@@ -1319,6 +1324,9 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIChannel* channel,
{
nsresult rv = NS_OK;
nsCOMPtr<nsIURI> aURL;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (!channel) return NS_ERROR_FAILURE;
rv = channel->GetURI(getter_AddRefs(aURL));
if (NS_FAILED(rv)) return rv;
@@ -1340,7 +1348,7 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIChannel* channel,
// if a plugin returns an error, the peer must kill the stream
// else the stream and PluginStreamListener leak
if (NS_FAILED(rv))
channel->Cancel(rv);
request->Cancel(rv);
}
else
{
@@ -1353,13 +1361,15 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIChannel* channel,
return rv;
}
NS_IMETHODIMP nsPluginStreamListenerPeer::OnStopRequest(nsIChannel* channel,
NS_IMETHODIMP nsPluginStreamListenerPeer::OnStopRequest(nsIRequest *request,
nsISupports* aContext,
nsresult aStatus,
const PRUnichar* aMsg)
{
nsresult rv = NS_OK;
nsCOMPtr<nsIURI> aURL;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (!channel) return NS_ERROR_FAILURE;
rv = channel->GetURI(getter_AddRefs(aURL));
if (NS_FAILED(rv)) return rv;
@@ -1367,7 +1377,11 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnStopRequest(nsIChannel* channel,
{
char* urlString;
nsCOMPtr<nsIFile> localFile;
rv = channel->GetLocalFile(getter_AddRefs(localFile));
nsCOMPtr<nsIFileChannel> fileChannel = do_QueryInterface(channel);
if (fileChannel)
rv = fileChannel->GetFile(getter_AddRefs(localFile));
if (NS_SUCCEEDED(rv) && localFile)
{
char* pathAndFilename;
@@ -1422,7 +1436,7 @@ nsresult nsPluginStreamListenerPeer::SetUpCache(nsIURI* aURL)
return NS_OpenURI(cacheListener, nsnull, aURL, nsnull);
}
nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIChannel* channel,
nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIRequest *request,
nsIURI* aURL)
{
nsresult rv = NS_OK;
@@ -1454,6 +1468,8 @@ nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIChannel* channel,
nsCOMPtr<nsIHTTPHeaderListener> headerListener =
do_QueryInterface(mPStreamListener);
if (headerListener) {
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
nsCOMPtr<nsIHTTPChannel> httpChannel = do_QueryInterface(channel);
if (httpChannel) {
ReadHeadersFromChannelAndPostToListener(httpChannel, headerListener);
@@ -1465,6 +1481,8 @@ nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIChannel* channel,
mPluginStreamInfo->SetSeekable(PR_FALSE);
// get Last-Modified header for plugin info
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
nsCOMPtr<nsIHTTPChannel> theHTTPChannel = do_QueryInterface(channel);
if (theHTTPChannel) {
char * lastModified;
@@ -3806,8 +3824,7 @@ NS_IMETHODIMP nsPluginHostImpl::NewPluginURLStream(const nsString& aURL,
}
}
rv = channel->AsyncRead(listenerPeer, nsnull);
rv = channel->AsyncOpen(listenerPeer, nsnull);
}
NS_RELEASE(listenerPeer);

1
modules/plugin/nglsrc/nsPluginHostImpl.h
View File

@@ -37,6 +37,7 @@ class ns4xPlugin;
class nsFileSpec;
class nsIComponentManager;
class nsIFile;
class nsIChannel;
/**
* A linked-list of plugin information that is used for

35
modules/plugin/nglsrc/nsPluginViewer.cpp
View File

@@ -157,14 +157,14 @@ public:
virtual ~PluginViewerImpl();
nsresult CreatePlugin(nsIPluginHost* aHost, const nsRect& aBounds,
nsresult CreatePlugin(nsIRequest* request, nsIPluginHost* aHost, const nsRect& aBounds,
nsIStreamListener*& aResult);
nsresult MakeWindow(nsNativeWidget aParent,
nsIDeviceContext* aDeviceContext,
const nsRect& aBounds);
nsresult StartLoad(nsIChannel* channel, nsIStreamListener*& aResult);
nsresult StartLoad(nsIRequest* request, nsIStreamListener*& aResult);
void ForceRefresh(void);
@@ -307,15 +307,18 @@ PluginViewerImpl::Init(nsIWidget* aParentWidget,
}
nsresult
PluginViewerImpl::StartLoad(nsIChannel* channel, nsIStreamListener*& aResult)
PluginViewerImpl::StartLoad(nsIRequest* request, nsIStreamListener*& aResult)
{
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (!channel) return NS_ERROR_FAILURE;
NS_IF_RELEASE(mChannel);
mChannel = channel;
NS_ADDREF(mChannel);
#ifdef DEBUG
char* contentType;
mChannel->GetContentType(&contentType);
channel->GetContentType(&contentType);
printf("PluginViewerImpl::StartLoad: content-type=%s\n", contentType);
nsCRT::free(contentType);
#endif
@@ -331,14 +334,14 @@ PluginViewerImpl::StartLoad(nsIChannel* channel, nsIStreamListener*& aResult)
{
nsRect r;
mWindow->GetClientBounds(r);
rv = CreatePlugin(host, nsRect(0, 0, r.width, r.height), aResult);
rv = CreatePlugin(request, host, nsRect(0, 0, r.width, r.height), aResult);
}
return rv;
}
nsresult
PluginViewerImpl::CreatePlugin(nsIPluginHost* aHost, const nsRect& aBounds,
PluginViewerImpl::CreatePlugin(nsIRequest* request, nsIPluginHost* aHost, const nsRect& aBounds,
nsIStreamListener*& aResult)
{
nsresult rv = NS_OK;
@@ -372,7 +375,9 @@ PluginViewerImpl::CreatePlugin(nsIPluginHost* aHost, const nsRect& aBounds,
nsCRT::free(spec);
char* ct;
rv = mChannel->GetContentType(&ct);
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
channel->GetContentType(&ct);
if (NS_FAILED(rv)) return rv;
rv = aHost->InstantiateFullPagePlugin(ct, str, aResult, mOwner);
delete[] ct;
@@ -692,43 +697,45 @@ PluginListener::~PluginListener()
NS_IMPL_ISUPPORTS(PluginListener, kIStreamListenerIID)
NS_IMETHODIMP
PluginListener::OnStartRequest(nsIChannel* channel, nsISupports *ctxt)
PluginListener::OnStartRequest(nsIRequest *request, nsISupports *ctxt)
{
nsresult rv;
char* contentType = nsnull;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
rv = channel->GetContentType(&contentType);
if (NS_FAILED(rv)) {
return rv;
}
rv = mViewer->StartLoad(channel, mNextStream);
rv = mViewer->StartLoad(request, mNextStream);
if (NS_FAILED(rv)) {
return rv;
}
if (nsnull == mNextStream)
return NS_ERROR_FAILURE;
return mNextStream->OnStartRequest(channel, ctxt);
return mNextStream->OnStartRequest(request, ctxt);
}
NS_IMETHODIMP
PluginListener::OnStopRequest(nsIChannel* channel, nsISupports *ctxt,
PluginListener::OnStopRequest(nsIRequest *request, nsISupports *ctxt,
nsresult status, const PRUnichar *errorMsg)
{
if (nsnull == mNextStream) {
return NS_ERROR_FAILURE;
}
return mNextStream->OnStopRequest(channel, ctxt, status, errorMsg);
return mNextStream->OnStopRequest(request, ctxt, status, errorMsg);
}
NS_IMETHODIMP
PluginListener::OnDataAvailable(nsIChannel* channel, nsISupports *ctxt,
PluginListener::OnDataAvailable(nsIRequest *request, nsISupports *ctxt,
nsIInputStream *inStr, PRUint32 sourceOffset, PRUint32 count)
{
if (nsnull == mNextStream) {
return NS_ERROR_FAILURE;
}
return mNextStream->OnDataAvailable(channel, ctxt, inStr, sourceOffset, count);
return mNextStream->OnDataAvailable(request, ctxt, inStr, sourceOffset, count);
}
//----------------------------------------------------------------------

1
netwerk/base/public/MANIFEST_IDL
View File

@@ -16,6 +16,7 @@ nsIRequest.idl
nsISocketTransportService.idl
nsIStreamIO.idl
nsIStreamListener.idl
nsITransport.idl
nsIStreamLoader.idl
nsIDownloader.idl
nsIStreamObserver.idl

1
netwerk/base/public/Makefile.in
View File

@@ -55,6 +55,7 @@ XPIDLSRCS = \
nsIStreamListener.idl \
nsIStreamProvider.idl \
nsIStreamLoader.idl \
nsITransport.idl \
nsISocketTransport.idl \
nsIURI.idl \
nsIURL.idl \

4
netwerk/base/public/makefile.win
View File

@@ -53,11 +53,13 @@ XPIDLSRCS = \
.\nsISocketTransport.idl \
.\nsISocketTransportService.idl \
.\nsIStreamIO.idl \
.\nsIStreamObserver.idl \
.\nsIStreamListener.idl \
.\nsIStreamProvider.idl \
.\nsIStreamLoader.idl \
.\nsIStreamProvider.idl \
.\nsITransport.idl \
.\nsIDownloader.idl \
.\nsIStreamObserver.idl \
.\nsIURI.idl \
.\nsIURL.idl \
.\nsIURLParser.idl \

151
netwerk/base/public/nsIChannel.idl
View File

@@ -36,35 +36,24 @@ interface nsIStreamIO;
typedef unsigned long nsLoadFlags;
/**
* The nsIChannel interface allows the user to construct I/O requests for
* The nsIChannel interface allows the user to construct get requests for
* specific protocols, and manage them in a uniform way. Once a channel
* is created (via nsIIOService::NewChannel), parameters for that request
* may be set by using the channel attributes, or by QueryInterfacing to a
* subclass of nsIChannel for protocol-specific parameters. Then the actual
* request can be issued in one of several ways:
*
* - AsyncRead and AsyncWrite allow for asynchronous requests, calling
* back the user's stream listener or provider,
* - OpenInputStream and OpenOutputStream allow for synchronous reads
* and writes on the underlying channel.
* - AsyncOpen is used for asynchronous reading, calling back the
* user's stream listener.
* - Open is used for synchronous read on the underlying channel.
*
* After a request has been completed, the channel is still valid for
* accessing protocol-specific results. For example, QueryInterfacing to
* nsIHTTPChannel allows response headers to be retrieved that result from
* http transactions.
*
* Note that a channel is really only valid for one request. Reusing a channel
* after a request has completed for a subsequent request may have undefined
* results, depending on the channel implementation.
*
* Also of note are a special kind of channel called "transports." Transports
* also implement the nsIChannel interface, but operate at a lower level from
* protocol channels. The socket and file transports are notable implementations
* of transports and allow higher level channels to be implemented. The cache
* may also behave as a transport, and possibly things like sound playing services
* etc. Transports usually operate in a separate thread and often multiplex
* multiple requests for the same kind of service or resources.
*/
[scriptable, uuid(1788e79e-f947-11d3-8cda-0060b0fc14a3)]
interface nsIChannel : nsIRequest
{
@@ -91,52 +80,6 @@ interface nsIChannel : nsIRequest
*/
attribute nsIURI URI;
/**
* Accesses the start offset from the beginning of the data from/to which
* reads/writes will occur. Users may set the transferOffset before making
* any of the following requests: asyncOpen, asyncRead, asyncWrite,
* openInputStream, openOutputstream.
*/
attribute unsigned long transferOffset;
/**
* Accesses the count of bytes to be transfered. For openInputStream and
* asyncRead, this specifies the amount to read, for asyncWrite, this
* specifies the amount to write (note that for openOutputStream, the
* end of the data can be signified simply by closing the stream).
* If the transferCount is set after reading has been initiated, the
* amount specified will become the current remaining amount to read
* before the channel is closed (this can be useful if the content
* length is encoded at the start of the stream).
*
* A transferCount value of -1 means the amount is unspecified, i.e.
* read or write all the data that is available.
*/
attribute long transferCount;
/**
* Accesses the load attributes for the channel. E.g. setting the load
* attributes with the LOAD_QUIET bit set causes the loading process to
* not deliver status notifications to the program performing the load,
* and to not contribute to keeping any nsILoadGroup it may be contained
* in from firing its OnLoadComplete notification.
*/
attribute nsLoadFlags loadAttributes;
/**
* Returns the content MIME type of the channel if available. Note that the
* content type can often be wrongly specified (wrong file extension, wrong
* MIME type, wrong document type stored on a server, etc.) and the caller
* most likely wants to verify with the actual data.
*/
attribute string contentType;
/**
* Returns the length of the data associated with the channel if available.
* If the length is unknown then -1 is returned.
*/
attribute long contentLength;
/**
* Accesses the owner corresponding to the entity that is
* responsible for this channel. Used by security code to grant
@@ -153,6 +96,15 @@ interface nsIChannel : nsIRequest
*/
attribute nsILoadGroup loadGroup;
/**
* Accesses the load attributes for the channel. E.g. setting the load
* attributes with the LOAD_QUIET bit set causes the loading process to
* not deliver status notifications to the program performing the load,
* and to not contribute to keeping any nsILoadGroup it may be contained
* in from firing its OnLoadComplete notification.
*/
attribute nsLoadFlags loadAttributes;
/**
* Accesses the capabilities callbacks of the channel. This is set by clients
* who wish to provide a means to receive progress, status and protocol-specific
@@ -166,37 +118,31 @@ interface nsIChannel : nsIRequest
readonly attribute nsISupports securityInfo;
/**
* Accesses the buffer segment size. The buffer segment size is used as
* the initial size for any transfer buffers, and the increment size for
* whenever the buffer space needs to be grown.
* (Note this parameter is passed along to any underlying nsIPipe objects.)
* If unspecified, the channel implementation picks a default.
* Returns the content MIME type of the channel if available. Note that the
* content type can often be wrongly specified (wrong file extension, wrong
* MIME type, wrong document type stored on a server, etc.) and the caller
* most likely wants to verify with the actual data.
*/
attribute unsigned long bufferSegmentSize;
attribute string contentType;
/**
* Accesses the buffer maximum size. The buffer maximum size is the limit
* size that buffer will be grown to before suspending the channel.
* (Note this parameter is passed along to any underlying nsIPipe objects.)
* If unspecified, the channel implementation picks a default.
* Returns the length of the data associated with the channel if available.
* If the length is unknown then -1 is returned.
*/
attribute unsigned long bufferMaxSize;
attribute long contentLength;
/**
* Returns a local file to the channel's data if one exists, null otherwise.
*/
readonly attribute nsIFile localFile;
* Open is used for synchronous read on the channel.
**/
nsIInputStream open();
/**
* Setting pipeliningAllowed causes the load of a URL (issued via
* asyncRead or asyncWrite) to be deferred in order to allow the request to
* be pipelined for greater throughput efficiency. Pipelined requests will
* be forced to load when the first non-pipelined request is issued.
*/
attribute boolean pipeliningAllowed;
/** AsyncOpen is used for asynchronous reading, calling back the
* user's stream listener.
**/
void asyncOpen(in nsIStreamListener listener, in nsISupports ctxt);
////////////////////////////////////////////////////////////////////////////
// Load attribute flags. These may be or'd together.
// Below are Load attribute flags which may be or'd together.
////////////////////////////////////////////////////////////////////////////
/**
* Note that more will follow for each protocol's implementation of a channel,
@@ -287,41 +233,7 @@ interface nsIChannel : nsIRequest
*/
const unsigned long LOAD_REPLACE = 1 << 16;
////////////////////////////////////////////////////////////////////////////
// nsIChannel operations
////////////////////////////////////////////////////////////////////////////
/**
* Opens a blocking input stream to the URI's specified source. This
* call may block until the input stream is available.
*/
nsIInputStream openInputStream();
/**
* Opens a blocking output stream to the URI's specified destination. This
* call may block until the output stream is available.
*/
nsIOutputStream openOutputStream();
/**
* Reads asynchronously from the URI's specified source. Notifications
* are provided to the stream listener on the calling thread.
*
* @param listener - notification handler.
* @param ctxt - application context passed to methods invoked on listener.
*/
void asyncRead(in nsIStreamListener listener,
in nsISupports ctxt);
/**
* Writes asynchronously to the URI's specified destination. Notifications
* are provided to the stream provider on the calling thread.
*
* @param provider - notification handler.
* @param ctxt - application context passed to methods invoked on provider.
*/
void asyncWrite(in nsIStreamProvider provider,
in nsISupports ctxt);
};
////////////////////////////////////////////////////////////////////////////////
@@ -334,8 +246,7 @@ interface nsIChannel : nsIRequest
[scriptable, uuid(308362ce-0d06-11d4-986e-00c04fa0cf4a)]
interface nsIStreamIOChannel : nsIChannel
{
void init(in nsIURI uri,
in nsIStreamIO io);
void init(in nsIURI uri, in nsIStreamIO io);
};
%{C++

4
netwerk/base/public/nsIDownloader.idl
View File

@@ -48,9 +48,7 @@ interface nsIDownloader : nsISupports
in boolean synchronous,
in nsILoadGroup loadGroup,
in nsIInterfaceRequestor notificationCallbacks,
in nsLoadFlags loadAttributes,
in unsigned long bufferSegmentSize,
in unsigned long bufferMaxSize);
in nsLoadFlags loadAttributes);
};
%{C++

8
netwerk/base/public/nsIFileTransportService.idl
View File

@@ -25,7 +25,7 @@
#include "nsFileSpec.h"
%}
interface nsIChannel;
interface nsITransport;
interface nsIEventSinkGetter;
interface nsIInputStream;
interface nsIRunnable;
@@ -35,18 +35,18 @@ interface nsIStreamIO;
[scriptable, uuid(57211a60-8c45-11d3-93ac-00104ba0fd40)]
interface nsIFileTransportService : nsISupports
{
nsIChannel createTransport(in nsIFile file,
nsITransport createTransport(in nsIFile file,
in long ioFlags,
in long perm);
// This version can be used with an existing input stream to serve
// as a data pump:
nsIChannel createTransportFromStream(in string name,
nsITransport createTransportFromStream(in string name,
in nsIInputStream fromStream,
in string contentType,
in long contentLength);
nsIChannel createTransportFromStreamIO(in nsIStreamIO io);
nsITransport createTransportFromStreamIO(in nsIStreamIO io);
void dispatchRequest(in nsIRunnable runnable);
void processPendingRequests();

9
netwerk/base/public/nsIIOService.idl
View File

@@ -104,15 +104,6 @@ interface nsIIOService : nsISupports
*/
attribute boolean offline;
/**
* Consumes all input from the channel, feading data to the specified stream
* listener. The function does not return until either all the data is
* consumed, or an error occurs.
*/
void consumeInput(in nsIChannel channel,
in nsISupports ctxt,
in nsIStreamListener consumer);
////////////////////////////////////////////////////////////////////////////
// URL parsing utilities

27
netwerk/base/public/nsILoadGroup.idl
View File

@@ -23,6 +23,7 @@
#include "nsIRequest.idl"
interface nsIChannel;
interface nsIRequest;
interface nsISimpleEnumerator;
interface nsIStreamObserver;
interface nsIStreamListener;
@@ -52,35 +53,35 @@ interface nsILoadGroup : nsIRequest
/**
* Accesses the default load channel for the group. Each time a number
* of channels are added to a group, the DefaultLoadChannel may be set
* to indicate that all of the channels are related to a particular URL.
* of request are added to a group, the DefaultLoadChannel may be set
* to indicate that all of the requests are related to a particular URL.
*/
attribute nsIChannel defaultLoadChannel;
attribute nsIRequest defaultLoadRequest;
/**
* Adds a new channel to the group. This will cause the default load
* attributes to be applied to that channel. If the channel added is
* the first channel in the group, the group's observer's OnStartRequest
* Adds a new request to the group. This will cause the default load
* attributes to be applied to that request. If the request added is
* the first request in the group, the group's observer's OnStartRequest
* method is called.
*/
void addChannel(in nsIChannel channel,
void addRequest(in nsIRequest request,
in nsISupports ctxt);
/**
* Removes a channel from the group. If the channel removed is
* the last channel in the group, the group's observer's OnStopRequest
* Removes a request from the group. If the request removed is
* the last request in the group, the group's observer's OnStopRequest
* method is called.
*/
void removeChannel(in nsIChannel channel,
void removeRequest(in nsIRequest request,
in nsISupports ctxt,
in nsresult status,
in wstring statusArg);
/**
* Returns the channels contained directly in this group.
* Enumerator element type: nsIChannel.
* Returns the requests contained directly in this group.
* Enumerator element type: nsIRequest.
*/
readonly attribute nsISimpleEnumerator channels;
readonly attribute nsISimpleEnumerator requests;
attribute nsIStreamObserver groupObserver;

8
netwerk/base/public/nsIProgressEventSink.idl
View File

@@ -23,7 +23,7 @@
#include "nsISupports.idl"
interface nsIURI;
interface nsIChannel;
interface nsIRequest;
/**
* An instance of nsIFfpEventSink should be passed as the eventSink
@@ -34,9 +34,9 @@ interface nsIChannel;
interface nsIProgressEventSink : nsISupports
{
/**
* Notify the EventSink that progress as occurred for the URL load.<BR>
* Notify the EventSink that progress has occurred for the URL load.<BR>
*/
void onProgress(in nsIChannel channel,
void onProgress(in nsIRequest request,
in nsISupports ctxt,
in unsigned long aProgress,
in unsigned long aProgressMax);
@@ -52,7 +52,7 @@ interface nsIProgressEventSink : nsISupports
* message. Multiple arguments can be passed by delimiting them
* with newline ('\n') characters.
*/
void onStatus(in nsIChannel channel,
void onStatus(in nsIRequest request,
in nsISupports ctxt,
in nsresult status,
in wstring statusArg);

7
netwerk/base/public/nsISocketTransport.idl
View File

@@ -20,11 +20,14 @@
* Contributor(s):
*/
#include "nsISupports.idl"
#include "nsITransport.idl"
[scriptable, uuid(785CA0F0-C39E-11d3-9ED6-0010A4053FD0)]
interface nsISocketTransport : nsISupports
interface nsISocketTransport : nsITransport
{
readonly attribute string host;
readonly attribute long port;
/**
*
*/

13
netwerk/base/public/nsISocketTransportService.idl
View File

@@ -22,8 +22,9 @@
#include "nsISupports.idl"
interface nsIChannel;
interface nsITransport;
interface nsIEventSinkGetter;
interface nsIChannel;
[scriptable, uuid(05331390-6884-11d3-9382-00104ba0fd40)]
interface nsISocketTransportService : nsISupports
@@ -36,14 +37,14 @@ interface nsISocketTransportService : nsISupports
* etc. The printHost contains the actual hostname (and not the
* proxy) for displaying in status messages.
*/
nsIChannel createTransport(in string host,
nsITransport createTransport(in string host,
in long port,
in string proxyHost,
in long proxyPort,
in unsigned long bufferSegmentSize,
in unsigned long bufferMaxSize);
nsIChannel createTransportOfType(in string socketType,
nsITransport createTransportOfType(in string socketType,
in string host,
in long port,
in string proxyHost,
@@ -51,7 +52,7 @@ interface nsISocketTransportService : nsISupports
in unsigned long bufferSegmentSize,
in unsigned long bufferMaxSize);
nsIChannel createTransportOfTypes(in unsigned long typeCount,
nsITransport createTransportOfTypes(in unsigned long typeCount,
[array, size_is(typeCount)] in string socketTypes,
in string host,
in long port,
@@ -66,11 +67,11 @@ interface nsISocketTransportService : nsISupports
* include- an error including server resets, an explicit
* Connection: close header (for HTTP) and timeouts!
*/
boolean reuseTransport(in nsIChannel i_Transport);
boolean reuseTransport(in nsITransport i_Transport);
void init ();
void shutdown();
void wakeup (in nsIChannel i_Transport);
void wakeup (in nsITransport i_Transport);
/**
* Total number of nsSocketTransport objects currently alive

6
netwerk/base/public/nsIStreamListener.idl
View File

@@ -22,7 +22,7 @@
#include "nsIStreamObserver.idl"
interface nsIChannel;
interface nsIRequest;
interface nsIInputStream;
interface nsIOutputStream;
interface nsIEventQueue;
@@ -37,7 +37,7 @@ interface nsIStreamListener : nsIStreamObserver
/**
* Called when there is data to be read from the channel.
*
* @param channel - the channel being read
* @param request - the request returned by AsyncRead
* @param ctxt - opaque parameter passed to AsyncRead
* @param input - temporary input stream for reading data chunk
* @param offset - current stream position (informational)
@@ -52,7 +52,7 @@ interface nsIStreamListener : nsIStreamObserver
* becomes available.
* @return <other-error> - if failure.
*/
void onDataAvailable(in nsIChannel channel,
void onDataAvailable(in nsIRequest request,
in nsISupports ctxt,
in nsIInputStream input,
in unsigned long offset,

9
netwerk/base/public/nsIStreamLoader.idl
View File

@@ -23,6 +23,7 @@
#include "nsISupports.idl"
#include "nsIChannel.idl"
interface nsIRequest;
interface nsIURI;
interface nsILoadGroup;
interface nsIStreamObserver;
@@ -47,9 +48,7 @@ interface nsIStreamLoader : nsISupports
in nsISupports ctxt,
in nsILoadGroup loadGroup,
in nsIInterfaceRequestor notificationCallbacks,
in nsLoadFlags loadAttributes,
in unsigned long bufferSegmentSize,
in unsigned long bufferMaxSize);
in nsLoadFlags loadAttributes);
/**
* Gets the number of bytes read so far.
@@ -57,9 +56,9 @@ interface nsIStreamLoader : nsISupports
readonly attribute unsigned long numBytesRead;
/**
* Gets the channel that loaded this file
* Gets the request that loaded this file
*/
readonly attribute nsIChannel channel;
readonly attribute nsIRequest request;
};

10
netwerk/base/public/nsIStreamObserver.idl
View File

@@ -22,7 +22,7 @@
#include "nsISupports.idl"
interface nsIChannel;
interface nsIRequest;
interface nsIEventQueue;
[scriptable, uuid(fd91e2e0-1481-11d3-9333-00104ba0fd40)]
@@ -31,22 +31,22 @@ interface nsIStreamObserver : nsISupports
/**
* Called to signify the beginning of an asynchronous request.
*
* @param channel - channel being observed
* @param request - request being observed
* @param ctxt - user specified data passed to AsyncRead/Write
*/
void onStartRequest(in nsIChannel channel,
void onStartRequest(in nsIRequest request,
in nsISupports ctxt);
/**
* Called to signify the end of an asynchronous request. This
* call is always preceded by a call to onStartRequest.
*
* @param channel - channel being observed
* @param request - request being observed
* @param ctxt - user specified data passed to AsyncRead/Write
* @param statusCode - reason for stopping (NS_OK if completed successfully)
* @param statusText - human readable reason for stopping (can be NULL)
*/
void onStopRequest(in nsIChannel channel,
void onStopRequest(in nsIRequest request,
in nsISupports ctxt,
in nsresult statusCode,
in wstring statusText);

4
netwerk/base/public/nsIStreamProvider.idl
View File

@@ -37,7 +37,7 @@ interface nsIStreamProvider : nsIStreamObserver
/**
* Called when data may be written to the channel.
*
* @param channel - the channel being written to
* @param request - the request returned by AsyncWrite
* @param ctxt - opaque parameter passed to AsyncWrite
* @param output - output stream for writing data chunk
* @param offset - current stream position (informational)
@@ -52,7 +52,7 @@ interface nsIStreamProvider : nsIStreamObserver
* becomes available.
* @return <other-error> - if failure.
*/
void onDataWritable(in nsIChannel channel,
void onDataWritable(in nsIRequest request,
in nsISupports ctxt,
in nsIOutputStream output,
in unsigned long offset,

105
netwerk/base/public/nsITransport.idl Normal file
View File

@@ -0,0 +1,105 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* The contents of this file are subject to the Netscape Public
* License Version 1.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
*/
#include "nsISupports.idl"
#include "nsIRequest.idl"
interface nsIStreamListener;
interface nsIStreamProvider;
interface nsIInputStream;
interface nsIOutputStream;
interface nsIProgressEventSink;
[scriptable, uuid(fd01f9a4-d492-4cf8-b76e-160ffc8c01e8)]
interface nsITransport : nsISupports
{
/**
* Get security info for this transport.
*/
readonly attribute nsISupports securityInfo;
/**
* Get/set the progress event sink for this transport.
*/
attribute nsIProgressEventSink progressEventSink;
/**
* Open an input stream on this transport.
*
* @param offset - read starting at this offset
* @param count - read this many bytes
* @param flags - optional transport specific flags
*/
nsIInputStream openInputStream(in unsigned long offset,
in unsigned long count,
in unsigned long flags);
/**
* Open an output stream on this transport.
*
* @param offset - write starting at this offset
* @param count - write no more than this many bytes
* @param flags - optional transport specific flags
*/
nsIOutputStream openOutputStream(in unsigned long offset,
in unsigned long count,
in unsigned long flags);
/**
* Asynchronously read data from the transport.
*
* @param listener - notify this listener when data is available
* @param ctxt - opaque parameter passed to listener methods
* @param offset - read starting at this offset
* @param count - read this many bytes
* @param flags - optional transport specific flags
*/
nsIRequest asyncRead(in nsIStreamListener listener,
in nsISupports ctxt,
in unsigned long offset,
in unsigned long count,
in unsigned long flags);
/**
* Asynchronously write data to the transport.
*
* @param provider - notify this provider when data can be written
* @param ctxt - opaque parameter passed to provider methods
* @param offset - write starting at this offset
* @param count - write this many bytes
* @param flags - optional transport specific flags
*/
nsIRequest asyncWrite(in nsIStreamProvider provider,
in nsISupports ctxt,
in unsigned long offset,
in unsigned long count,
in unsigned long flags);
};
[scriptable, uuid(d7abf5a4-ce72-482a-9217-a219a905c019)]
interface nsITransportRequest : nsIRequest
{
/**
* Get the transport associated with this request.
*/
readonly attribute nsITransport transport;
};

113
netwerk/base/public/nsNetUtil.h
View File

@@ -36,6 +36,7 @@
#include "nsIIOService.h"
#include "nsIServiceManager.h"
#include "nsIChannel.h"
#include "nsITransport.h"
#include "nsMemory.h"
#include "nsCOMPtr.h"
#include "nsIHTTPProtocolHandler.h"
@@ -94,9 +95,7 @@ NS_OpenURI(nsIChannel* *result,
nsIIOService* ioService = nsnull, // pass in nsIIOService to optimize callers
nsILoadGroup* loadGroup = nsnull,
nsIInterfaceRequestor* notificationCallbacks = nsnull,
nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIChannel::LOAD_NORMAL),
PRUint32 bufferSegmentSize = 0,
PRUint32 bufferMaxSize = 0)
nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIChannel::LOAD_NORMAL))
{
nsresult rv;
@@ -123,14 +122,6 @@ NS_OpenURI(nsIChannel* *result,
rv = channel->SetLoadAttributes(loadAttributes);
if (NS_FAILED(rv)) return rv;
}
if (bufferSegmentSize != 0) {
rv = channel->SetBufferSegmentSize(bufferSegmentSize);
if (NS_FAILED(rv)) return rv;
}
if (bufferMaxSize != 0) {
rv = channel->SetBufferMaxSize(bufferMaxSize);
if (NS_FAILED(rv)) return rv;
}
*result = channel;
return rv;
@@ -148,20 +139,17 @@ NS_OpenURI(nsIInputStream* *result,
nsIIOService* ioService = nsnull, // pass in nsIIOService to optimize callers
nsILoadGroup* loadGroup = nsnull,
nsIInterfaceRequestor* notificationCallbacks = nsnull,
nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIChannel::LOAD_NORMAL),
PRUint32 bufferSegmentSize = 0,
PRUint32 bufferMaxSize = 0)
nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIChannel::LOAD_NORMAL))
{
nsresult rv;
nsCOMPtr<nsIChannel> channel;
rv = NS_OpenURI(getter_AddRefs(channel), uri, ioService,
loadGroup, notificationCallbacks, loadAttributes,
bufferSegmentSize, bufferMaxSize);
loadGroup, notificationCallbacks, loadAttributes);
if (NS_FAILED(rv)) return rv;
nsIInputStream* inStr;
rv = channel->OpenInputStream(&inStr);
rv = channel->Open(&inStr);
if (NS_FAILED(rv)) return rv;
*result = inStr;
@@ -175,19 +163,16 @@ NS_OpenURI(nsIStreamListener* aConsumer,
nsIIOService* ioService = nsnull, // pass in nsIIOService to optimize callers
nsILoadGroup* loadGroup = nsnull,
nsIInterfaceRequestor* notificationCallbacks = nsnull,
nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIChannel::LOAD_NORMAL),
PRUint32 bufferSegmentSize = 0,
PRUint32 bufferMaxSize = 0)
nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIChannel::LOAD_NORMAL))
{
nsresult rv;
nsCOMPtr<nsIChannel> channel;
rv = NS_OpenURI(getter_AddRefs(channel), uri, ioService,
loadGroup, notificationCallbacks, loadAttributes,
bufferSegmentSize, bufferMaxSize);
loadGroup, notificationCallbacks, loadAttributes);
if (NS_FAILED(rv)) return rv;
rv = channel->AsyncRead(aConsumer, context);
rv = channel->AsyncOpen(aConsumer, context);
return rv;
}
@@ -326,9 +311,7 @@ NS_NewDownloader(nsIDownloader* *result,
PRBool synchronous = PR_FALSE,
nsILoadGroup* loadGroup = nsnull,
nsIInterfaceRequestor* notificationCallbacks = nsnull,
nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIChannel::LOAD_NORMAL),
PRUint32 bufferSegmentSize = 0,
PRUint32 bufferMaxSize = 0)
nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIChannel::LOAD_NORMAL))
{
nsresult rv;
nsCOMPtr<nsIDownloader> downloader;
@@ -338,8 +321,8 @@ NS_NewDownloader(nsIDownloader* *result,
NS_GET_IID(nsIDownloader),
getter_AddRefs(downloader));
if (NS_FAILED(rv)) return rv;
rv = downloader->Init(uri, observer, context, synchronous, loadGroup, notificationCallbacks,
loadAttributes, bufferSegmentSize, bufferMaxSize);
rv = downloader->Init(uri, observer, context, synchronous, loadGroup,
notificationCallbacks, loadAttributes);
if (NS_FAILED(rv)) return rv;
*result = downloader;
NS_ADDREF(*result);
@@ -353,9 +336,7 @@ NS_NewStreamLoader(nsIStreamLoader* *result,
nsISupports* context = nsnull,
nsILoadGroup* loadGroup = nsnull,
nsIInterfaceRequestor* notificationCallbacks = nsnull,
nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIChannel::LOAD_NORMAL),
PRUint32 bufferSegmentSize = 0,
PRUint32 bufferMaxSize = 0)
nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIChannel::LOAD_NORMAL))
{
nsresult rv;
nsCOMPtr<nsIStreamLoader> loader;
@@ -365,8 +346,9 @@ NS_NewStreamLoader(nsIStreamLoader* *result,
NS_GET_IID(nsIStreamLoader),
getter_AddRefs(loader));
if (NS_FAILED(rv)) return rv;
rv = loader->Init(uri, observer, context, loadGroup, notificationCallbacks, loadAttributes,
bufferSegmentSize, bufferMaxSize);
rv = loader->Init(uri, observer, context, loadGroup,
notificationCallbacks, loadAttributes);
if (NS_FAILED(rv)) return rv;
*result = loader;
NS_ADDREF(*result);
@@ -393,9 +375,7 @@ NS_NewStreamObserverProxy(nsIStreamObserver **aResult,
rv = proxy->Init(aObserver, aEventQ);
if (NS_FAILED(rv)) return rv;
*aResult = proxy;
NS_ADDREF(*aResult);
NS_ADDREF(*aResult = proxy);
return NS_OK;
}
@@ -421,9 +401,7 @@ NS_NewStreamListenerProxy(nsIStreamListener **aResult,
rv = proxy->Init(aListener, aEventQ, aBufferSegmentSize, aBufferMaxSize);
if (NS_FAILED(rv)) return rv;
*aResult = proxy;
NS_ADDREF(*aResult);
NS_ADDREF(*aResult = proxy);
return NS_OK;
}
@@ -449,9 +427,7 @@ NS_NewStreamProviderProxy(nsIStreamProvider **aResult,
rv = proxy->Init(aProvider, aEventQ, aBufferSegmentSize, aBufferMaxSize);
if (NS_FAILED(rv)) return rv;
*aResult = proxy;
NS_ADDREF(*aResult);
NS_ADDREF(*aResult = proxy);
return NS_OK;
}
@@ -474,9 +450,7 @@ NS_NewSimpleStreamListener(nsIStreamListener **aResult,
rv = listener->Init(aSink, aObserver);
if (NS_FAILED(rv)) return rv;
*aResult = listener.get();
NS_ADDREF(*aResult);
NS_ADDREF(*aResult = listener);
return NS_OK;
}
@@ -499,9 +473,7 @@ NS_NewSimpleStreamProvider(nsIStreamProvider **aResult,
rv = provider->Init(aSource, aObserver);
if (NS_FAILED(rv)) return rv;
*aResult = provider.get();
NS_ADDREF(*aResult);
NS_ADDREF(*aResult = provider);
return NS_OK;
}
@@ -522,8 +494,7 @@ NS_NewAsyncStreamObserver(nsIStreamObserver **result,
rv = obs->Init(receiver, eventQueue);
if (NS_FAILED(rv)) return rv;
*result = obs;
NS_ADDREF(*result);
NS_ADDREF(*result = obs);
return NS_OK;
}
@@ -544,8 +515,7 @@ NS_NewAsyncStreamListener(nsIStreamListener **result,
rv = lsnr->Init(receiver, eventQueue);
if (NS_FAILED(rv)) return rv;
*result = lsnr;
NS_ADDREF(*result);
NS_ADDREF(*result = lsnr);
return NS_OK;
}
@@ -572,25 +542,26 @@ NS_NewSyncStreamListener(nsIInputStream **aInStream,
rv = NS_NewSimpleStreamListener(aResult, pipeOut);
if (NS_FAILED(rv)) return rv;
*aInStream = pipeIn;
NS_ADDREF(*aInStream);
*aOutStream = pipeOut;
NS_ADDREF(*aOutStream);
NS_ADDREF(*aInStream = pipeIn);
NS_ADDREF(*aOutStream = pipeOut);
return NS_OK;
}
//
// Calls AsyncWrite on the specified channel, with a stream provider that
// Calls AsyncWrite on the specified transport, with a stream provider that
// reads data from the specified input stream.
//
inline nsresult
NS_AsyncWriteFromStream(nsIChannel *aChannel,
NS_AsyncWriteFromStream(nsIRequest **aRequest,
nsITransport *aTransport,
nsIInputStream *aSource,
PRUint32 aOffset=0,
PRUint32 aCount=0,
PRUint32 aFlags=0,
nsIStreamObserver *aObserver=NULL,
nsISupports *aContext=NULL)
{
NS_ENSURE_ARG_POINTER(aChannel);
NS_ENSURE_ARG_POINTER(aTransport);
nsresult rv;
nsCOMPtr<nsIStreamProvider> provider;
@@ -599,20 +570,28 @@ NS_AsyncWriteFromStream(nsIChannel *aChannel,
aObserver);
if (NS_FAILED(rv)) return rv;
return aChannel->AsyncWrite(provider, aContext);
return aTransport->AsyncWrite(provider, aContext,
aOffset,
aCount,
aFlags,
getter_AddRefs(aRequest));
}
//
// Calls AsyncRead on the specified channel, with a stream listener that
// Calls AsyncRead on the specified transport, with a stream listener that
// writes data to the specified output stream.
//
inline nsresult
NS_AsyncReadToStream(nsIChannel *aChannel,
NS_AsyncReadToStream(nsIRequest **aRequest,
nsITransport *aTransport,
nsIOutputStream *aSink,
PRUint32 aOffset=0,
PRUint32 aCount=0,
PRUint32 aFlags=0,
nsIStreamObserver *aObserver=NULL,
nsISupports *aContext=NULL)
{
NS_ENSURE_ARG_POINTER(aChannel);
NS_ENSURE_ARG_POINTER(aTransport);
nsresult rv;
nsCOMPtr<nsIStreamListener> listener;
@@ -621,7 +600,11 @@ NS_AsyncReadToStream(nsIChannel *aChannel,
aObserver);
if (NS_FAILED(rv)) return rv;
return aChannel->AsyncRead(listener, aContext);
return aTransport->AsyncRead(listener, aContext,
aOffset,
aCount,
aFlags,
getter_AddRefs(aRequest));
}
#endif // nsNetUtil_h__

4
netwerk/base/public/security-prefs.js
View File

@@ -9,3 +9,7 @@ pref("security.warn_entering_secure", true);
pref("security.warn_leaving_secure", true);
pref("security.warn_viewing_mixed", true);
pref("security.warn_submit_insecure", true);
pref("security.ui.enable", true);

50
netwerk/base/src/nsAsyncStreamListener.cpp
View File

@@ -48,7 +48,7 @@ class nsStreamListenerEvent
{
public:
nsStreamListenerEvent(nsAsyncStreamObserver* listener,
nsIChannel* channel, nsISupports* context);
nsIRequest* request, nsISupports* context);
virtual ~nsStreamListenerEvent();
nsresult Fire(nsIEventQueue* aEventQ);
@@ -60,7 +60,7 @@ protected:
static void PR_CALLBACK DestroyPLEvent(PLEvent* aEvent);
nsAsyncStreamObserver* mListener;
nsIChannel* mChannel;
nsIRequest* mRequest;
nsISupports* mContext;
PLEvent mEvent;
};
@@ -71,13 +71,13 @@ protected:
////////////////////////////////////////////////////////////////////////////////
nsStreamListenerEvent::nsStreamListenerEvent(nsAsyncStreamObserver* listener,
nsIChannel* channel, nsISupports* context)
: mListener(listener), mChannel(channel), mContext(context)
nsIRequest* request, nsISupports* context)
: mListener(listener), mRequest(request), mContext(context)
{
MOZ_COUNT_CTOR(nsStreamListenerEvent);
NS_IF_ADDREF(mListener);
NS_IF_ADDREF(mChannel);
NS_IF_ADDREF(mRequest);
NS_IF_ADDREF(mContext);
}
@@ -86,7 +86,7 @@ nsStreamListenerEvent::~nsStreamListenerEvent()
MOZ_COUNT_DTOR(nsStreamListenerEvent);
NS_IF_RELEASE(mListener);
NS_IF_RELEASE(mChannel);
NS_IF_RELEASE(mRequest);
NS_IF_RELEASE(mContext);
}
@@ -105,7 +105,7 @@ void PR_CALLBACK nsStreamListenerEvent::HandlePLEvent(PLEvent* aEvent)
// the pipe to empty...
//
if (NS_FAILED(rv)) {
nsresult cancelRv = ev->mChannel->Cancel(rv);
nsresult cancelRv = ev->mRequest->Cancel(rv);
NS_ASSERTION(NS_SUCCEEDED(cancelRv), "Cancel failed");
}
}
@@ -182,8 +182,8 @@ class nsOnStartRequestEvent : public nsStreamListenerEvent
{
public:
nsOnStartRequestEvent(nsAsyncStreamObserver* listener,
nsIChannel* channel, nsISupports* context)
: nsStreamListenerEvent(listener, channel, context) {}
nsIRequest* request, nsISupports* context)
: nsStreamListenerEvent(listener, request, context) {}
virtual ~nsOnStartRequestEvent() {}
NS_IMETHOD HandleEvent();
@@ -205,19 +205,19 @@ nsOnStartRequestEvent::HandleEvent()
}
nsresult status;
nsresult rv = mChannel->GetStatus(&status);
nsresult rv = mRequest->GetStatus(&status);
NS_ASSERTION(NS_SUCCEEDED(rv), "GetStatus failed");
rv = receiver->OnStartRequest(mChannel, mContext);
rv = receiver->OnStartRequest(mRequest, mContext);
return rv;
}
NS_IMETHODIMP
nsAsyncStreamObserver::OnStartRequest(nsIChannel* channel, nsISupports* context)
nsAsyncStreamObserver::OnStartRequest(nsIRequest *request, nsISupports* context)
{
nsresult rv;
nsOnStartRequestEvent* event =
new nsOnStartRequestEvent(this, channel, context);
new nsOnStartRequestEvent(this, request, context);
if (event == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
@@ -252,8 +252,8 @@ class nsOnStopRequestEvent : public nsStreamListenerEvent
{
public:
nsOnStopRequestEvent(nsAsyncStreamObserver* listener,
nsISupports* context, nsIChannel* channel)
: nsStreamListenerEvent(listener, channel, context),
nsISupports* context, nsIRequest* request)
: nsStreamListenerEvent(listener, request, context),
mStatus(NS_OK) {}
virtual ~nsOnStopRequestEvent();
@@ -293,7 +293,7 @@ nsOnStopRequestEvent::HandleEvent()
}
nsresult status = NS_OK;
nsresult rv = mChannel->GetStatus(&status);
nsresult rv = mRequest->GetStatus(&status);
NS_ASSERTION(NS_SUCCEEDED(rv), "GetStatus failed");
//
@@ -303,14 +303,14 @@ nsOnStopRequestEvent::HandleEvent()
if (NS_SUCCEEDED(rv) && NS_FAILED(status)) {
mStatus = status;
}
rv = receiver->OnStopRequest(mChannel, mContext, mStatus, mStatusArg.GetUnicode());
rv = receiver->OnStopRequest(mRequest, mContext, mStatus, mStatusArg.GetUnicode());
// Call clear on the listener to make sure it's cleanup is done on the correct thread
mListener->Clear();
return rv;
}
NS_IMETHODIMP
nsAsyncStreamObserver::OnStopRequest(nsIChannel* channel, nsISupports* context,
nsAsyncStreamObserver::OnStopRequest(nsIRequest* request, nsISupports* context,
nsresult aStatus, const PRUnichar* aStatusArg)
{
nsresult rv;
@@ -320,7 +320,7 @@ nsAsyncStreamObserver::OnStopRequest(nsIChannel* channel, nsISupports* context,
// Status is...
//
nsOnStopRequestEvent* event =
new nsOnStopRequestEvent(this, context, channel);
new nsOnStopRequestEvent(this, context, request);
if (event == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
@@ -354,8 +354,8 @@ class nsOnDataAvailableEvent : public nsStreamListenerEvent
{
public:
nsOnDataAvailableEvent(nsAsyncStreamObserver* listener,
nsIChannel* channel, nsISupports* context)
: nsStreamListenerEvent(listener, channel, context),
nsIRequest* request, nsISupports* context)
: nsStreamListenerEvent(listener, request, context),
mIStream(nsnull), mLength(0) {}
virtual ~nsOnDataAvailableEvent();
@@ -401,7 +401,7 @@ nsOnDataAvailableEvent::HandleEvent()
}
nsresult status;
nsresult rv = mChannel->GetStatus(&status);
nsresult rv = mRequest->GetStatus(&status);
NS_ASSERTION(NS_SUCCEEDED(rv), "GetStatus failed");
//
@@ -409,7 +409,7 @@ nsOnDataAvailableEvent::HandleEvent()
// have succeeded...
//
if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(status)) {
rv = receiver->OnDataAvailable(mChannel, mContext,
rv = receiver->OnDataAvailable(mRequest, mContext,
mIStream, mSourceOffset, mLength);
}
else {
@@ -419,14 +419,14 @@ nsOnDataAvailableEvent::HandleEvent()
}
NS_IMETHODIMP
nsAsyncStreamListener::OnDataAvailable(nsIChannel* channel, nsISupports* context,
nsAsyncStreamListener::OnDataAvailable(nsIRequest* request, nsISupports* context,
nsIInputStream *aIStream,
PRUint32 aSourceOffset,
PRUint32 aLength)
{
nsresult rv;
nsOnDataAvailableEvent* event =
new nsOnDataAvailableEvent(this, channel, context);
new nsOnDataAvailableEvent(this, request, context);
if (event == nsnull)
return NS_ERROR_OUT_OF_MEMORY;

12
netwerk/base/src/nsAsyncStreamListener.h
View File

@@ -28,7 +28,7 @@
#include "nsIEventQueue.h"
#include "nsIStreamObserver.h"
#include "nsIStreamListener.h"
#include "nsIRequest.h"
////////////////////////////////////////////////////////////////////////////////
class nsAsyncStreamObserver : public nsIAsyncStreamObserver
@@ -66,20 +66,20 @@ public:
NS_DECL_ISUPPORTS_INHERITED
// nsIStreamListener methods:
NS_IMETHOD OnStartRequest(nsIChannel* channel,
NS_IMETHOD OnStartRequest(nsIRequest* request,
nsISupports* context)
{
return nsAsyncStreamObserver::OnStartRequest(channel, context);
return nsAsyncStreamObserver::OnStartRequest(request, context);
}
NS_IMETHOD OnStopRequest(nsIChannel* channel,
NS_IMETHOD OnStopRequest(nsIRequest* request,
nsISupports* context,
nsresult aStatus, const PRUnichar* aStatusArg)
{
return nsAsyncStreamObserver::OnStopRequest(channel, context, aStatus, aStatusArg);
return nsAsyncStreamObserver::OnStopRequest(request, context, aStatus, aStatusArg);
}
NS_IMETHOD OnDataAvailable(nsIChannel* channel, nsISupports* context,
NS_IMETHOD OnDataAvailable(nsIRequest* request, nsISupports* context,
nsIInputStream *aIStream,
PRUint32 aSourceOffset,
PRUint32 aLength);

26
netwerk/base/src/nsDownloader.cpp
View File

@@ -43,9 +43,7 @@ nsDownloader::Init(nsIURI* aURL,
PRBool aIsSynchronous,
nsILoadGroup* aGroup,
nsIInterfaceRequestor* aNotificationCallbacks,
nsLoadFlags aLoadAttributes,
PRUint32 aBufferSegmentSize,
PRUint32 aBufferMaxSize)
nsLoadFlags aLoadAttributes)
{
nsresult rv;
mObserver = aObserver;
@@ -55,10 +53,13 @@ nsDownloader::Init(nsIURI* aURL,
aLoadAttributes |= nsIChannel::CACHE_AS_FILE;
rv = NS_OpenURI(getter_AddRefs(channel), aURL, nsnull, aGroup, aNotificationCallbacks,
aLoadAttributes, aBufferSegmentSize, aBufferMaxSize);
aLoadAttributes);
if (NS_SUCCEEDED(rv) && channel)
rv = channel->GetLocalFile(getter_AddRefs(localFile));
{
nsCOMPtr<nsIFileChannel> fc = do_QueryInterface(channel);
if (fc)
rv = fc->GetFile(getter_AddRefs(localFile));
}
if (mObserver && (NS_FAILED(rv) || localFile))
{
if (aIsSynchronous)
@@ -81,8 +82,7 @@ nsDownloader::Init(nsIURI* aURL,
return pObserver->OnDownloadComplete(this, mContext, rv, localFile);
}
}
return channel->AsyncRead(this, aContext);
return channel->AsyncOpen(this, aContext);
}
NS_METHOD
@@ -103,13 +103,13 @@ NS_IMPL_ISUPPORTS3(nsDownloader, nsIDownloader,
nsIStreamObserver, nsIStreamListener)
NS_IMETHODIMP
nsDownloader::OnStartRequest(nsIChannel* channel, nsISupports *ctxt)
nsDownloader::OnStartRequest(nsIRequest *request, nsISupports *ctxt)
{
return NS_OK;
}
NS_IMETHODIMP
nsDownloader::OnStopRequest(nsIChannel* channel, nsISupports *ctxt,
nsDownloader::OnStopRequest(nsIRequest *request, nsISupports *ctxt,
nsresult aStatus, const PRUnichar* aStatusArg)
{
nsCOMPtr<nsIFile> file;
@@ -117,6 +117,10 @@ nsDownloader::OnStopRequest(nsIChannel* channel, nsISupports *ctxt,
{
nsresult rv;
nsCOMPtr<nsIURI> uri;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request, &rv);
if (NS_FAILED(rv)) return rv;
rv = channel->GetURI(getter_AddRefs(uri));
if (NS_FAILED(rv)) return rv;
nsXPIDLCString spec;
@@ -147,7 +151,7 @@ nsDownloader::OnStopRequest(nsIChannel* channel, nsISupports *ctxt,
#define BUF_SIZE 1024
NS_IMETHODIMP
nsDownloader::OnDataAvailable(nsIChannel* channel, nsISupports *ctxt,
nsDownloader::OnDataAvailable(nsIRequest *request, nsISupports *ctxt,
nsIInputStream *inStr,
PRUint32 sourceOffset, PRUint32 count)
{

216
netwerk/base/src/nsFileTransport.cpp
View File

@@ -208,7 +208,6 @@ nsFileTransport::nsFileTransport()
mOffset(0),
mTotalAmount(-1),
mTransferAmount(-1),
mLoadAttributes(LOAD_NORMAL),
mSourceWrapper(nsnull),
mSinkWrapper(nsnull),
mService(nsnull)
@@ -283,8 +282,9 @@ nsFileTransport::~nsFileTransport()
PR_AtomicDecrement(&mService->mTotalTransports);
}
NS_IMPL_THREADSAFE_ISUPPORTS3(nsFileTransport,
nsIChannel,
NS_IMPL_THREADSAFE_ISUPPORTS4(nsFileTransport,
nsITransport,
nsITransportRequest,
nsIRequest,
nsIRunnable)
@@ -384,52 +384,80 @@ nsFileTransport::Resume()
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// From nsITransportRequest
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsFileTransport::GetTransport(nsITransport **result)
{
NS_ENSURE_ARG_POINTER(result);
NS_ADDREF(*result = this);
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// From nsITransport
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsFileTransport::OpenInputStream(nsIInputStream **result)
nsFileTransport::OpenInputStream(PRUint32 aTransferOffset,
PRUint32 aTransferCount,
PRUint32 aFlags,
nsIInputStream **aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
nsresult rv;
nsCOMPtr<nsIInputStream> in;
rv = mStreamIO->GetInputStream(getter_AddRefs(in));
if (NS_FAILED(rv)) return rv;
NS_ASSERTION(mTransferAmount == -1, "need to wrap input stream in one that truncates");
if (mOffset > 0) {
NS_ASSERTION(aTransferCount == (PRUint32) -1, "need to wrap input stream in one that truncates");
if (aTransferOffset > 0) {
nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(in, &rv);
if (NS_FAILED(rv)) return rv;
rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, mOffset);
rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, aTransferOffset);
if (NS_FAILED(rv)) return rv;
}
*result = in;
NS_ADDREF(*result);
NS_ADDREF(*aResult = in);
return rv;
}
NS_IMETHODIMP
nsFileTransport::OpenOutputStream(nsIOutputStream **result)
nsFileTransport::OpenOutputStream(PRUint32 aTransferOffset,
PRUint32 aTransferCount,
PRUint32 aFlags,
nsIOutputStream **aResult)
{
return mStreamIO->GetOutputStream(result);
NS_ASSERTION(aTransferOffset == 0, "need to seek to specified offset");
NS_ASSERTION(aTransferCount == (PRUint32) -1, "need to wrap output stream in one that truncates");
return mStreamIO->GetOutputStream(aResult);
}
NS_IMETHODIMP
nsFileTransport::AsyncRead(nsIStreamListener *listener, nsISupports *ctxt)
nsFileTransport::AsyncRead(nsIStreamListener *aListener,
nsISupports *aContext,
PRUint32 aTransferOffset,
PRUint32 aTransferCount,
PRUint32 aFlags,
nsIRequest **aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
nsresult rv = NS_OK;
if (mXferState != CLOSED)
return NS_ERROR_IN_PROGRESS;
NS_ASSERTION(listener, "need to supply an nsIStreamListener");
NS_ASSERTION(aListener, "need to supply an nsIStreamListener");
rv = NS_NewStreamListenerProxy(getter_AddRefs(mListener),
listener, nsnull,
aListener, nsnull,
mBufferSegmentSize,
mBufferMaxSize);
if (NS_FAILED(rv)) return rv;
NS_ASSERTION(mContext == nsnull, "context not released");
mContext = ctxt;
mContext = aContext;
mOffset = aTransferOffset;
mTransferAmount = aTransferCount;
mXferState = OPEN_FOR_READ;
LOG(("nsFileTransport: AsyncRead [this=%x %s] mOffset=%d mTransferAmount=%d\n",
@@ -441,27 +469,38 @@ nsFileTransport::AsyncRead(nsIStreamListener *listener, nsISupports *ctxt)
rv = mService->DispatchRequest(this);
if (NS_FAILED(rv)) return rv;
NS_ADDREF(*aResult = this);
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::AsyncWrite(nsIStreamProvider *provider,
nsISupports *ctxt)
nsFileTransport::AsyncWrite(nsIStreamProvider *aProvider,
nsISupports *aContext,
PRUint32 aTransferOffset,
PRUint32 aTransferCount,
PRUint32 aFlags,
nsIRequest **aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
nsresult rv = NS_OK;
LOG(("nsFileTransport: AsyncWrite [this=%x, provider=%x]\n",
this, provider));
this, aProvider));
if (mXferState != CLOSED)
return NS_ERROR_IN_PROGRESS;
NS_ASSERTION(provider, "need to supply an nsIStreamProvider");
rv = NS_NewStreamProviderProxy(getter_AddRefs(mProvider), provider);
NS_ASSERTION(aProvider, "need to supply an nsIStreamProvider");
rv = NS_NewStreamProviderProxy(getter_AddRefs(mProvider),
aProvider, nsnull,
mBufferSegmentSize,
mBufferMaxSize);
if (NS_FAILED(rv)) return rv;
NS_ASSERTION(mContext == nsnull, "context not released");
mContext = ctxt;
mContext = aContext;
mOffset = aTransferOffset;
mTransferAmount = aTransferCount;
mXferState = OPEN_FOR_WRITE;
LOG(("nsFileTransport: AsyncWrite [this=%x %s] mOffset=%d mTransferAmount=%d\n",
@@ -473,6 +512,7 @@ nsFileTransport::AsyncWrite(nsIStreamProvider *provider,
rv = mService->DispatchRequest(this);
if (NS_FAILED(rv)) return rv;
NS_ADDREF(*aResult = this);
return NS_OK;
}
@@ -671,8 +711,8 @@ nsFileTransport::Process(void)
LOG(("nsFileTransport: READING [this=%x %s] read %u bytes [offset=%u]\n",
this, mStreamName.GetBuffer(), total, mOffset));
if (mProgress && !(mLoadAttributes & LOAD_BACKGROUND)
&& (mTransferAmount >= 0)) {
// what about check for background flags! dougt
if (mProgress && (mTransferAmount >= 0)) {
mProgress->OnProgress(this, mContext,
mTotalAmount - mTransferAmount,
mTotalAmount);
@@ -704,7 +744,8 @@ nsFileTransport::Process(void)
mListener->OnStopRequest(this, mContext, mStatus, nsnull);
mListener = 0;
}
if (mProgress && !(mLoadAttributes & LOAD_BACKGROUND)) {
// what about check for background flag! dougt
if (mProgress) {
nsAutoString fileName;
fileName.AssignWithConversion(mStreamName);
mProgress->OnStatus(this, mContext,
@@ -717,7 +758,6 @@ nsFileTransport::Process(void)
mSource = 0;
NS_IF_RELEASE(mSourceWrapper);
mSourceWrapper = nsnull;
mXferState = CLOSING;
break;
}
@@ -843,9 +883,8 @@ nsFileTransport::Process(void)
else
LOG(("nsFileTransport: WRITING [this=%x %s] wrote %u bytes [offset=%u]\n",
this, mStreamName.GetBuffer(), total, mOffset));
if (mProgress && !(mLoadAttributes & LOAD_BACKGROUND)
&& (mTransferAmount >= 0))
// what about check for background flag dougt!
if (mProgress && (mTransferAmount >= 0))
mProgress->OnProgress(this, mContext,
mTotalAmount - mTransferAmount,
mTotalAmount);
@@ -875,14 +914,13 @@ nsFileTransport::Process(void)
NS_IF_RELEASE(mSinkWrapper);
mSinkWrapper = nsnull;
nsresult rv;
if (mProvider) {
mProvider->OnStopRequest(this, mContext, mStatus, nsnull);
mProvider = 0;
}
if (mProgress && !(mLoadAttributes & LOAD_BACKGROUND)) {
if (mProgress) {
nsAutoString fileName; fileName.AssignWithConversion(mStreamName);
rv = mProgress->OnStatus(this, mContext,
nsresult rv = mProgress->OnStatus(this, mContext,
NS_NET_STATUS_WROTE_TO,
fileName.GetUnicode());
NS_ASSERTION(NS_SUCCEEDED(rv), "unexpected OnStatus failure");
@@ -928,6 +966,7 @@ nsFileTransport::DoClose(void)
// other nsIChannel methods:
////////////////////////////////////////////////////////////////////////////////
#if 0
NS_IMETHODIMP
nsFileTransport::GetOriginalURI(nsIURI* *aURI)
{
@@ -1005,90 +1044,6 @@ nsFileTransport::SetContentLength(PRInt32 aContentLength)
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsFileTransport::GetTransferOffset(PRUint32 *aTransferOffset)
{
*aTransferOffset = mOffset;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::SetTransferOffset(PRUint32 aTransferOffset)
{
mOffset = aTransferOffset;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::GetTransferCount(PRInt32 *aTransferCount)
{
*aTransferCount = mTransferAmount;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::SetTransferCount(PRInt32 aTransferCount)
{
mTransferAmount = aTransferCount;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::GetBufferSegmentSize(PRUint32 *aBufferSegmentSize)
{
*aBufferSegmentSize = mBufferSegmentSize;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::SetBufferSegmentSize(PRUint32 aBufferSegmentSize)
{
mBufferSegmentSize = aBufferSegmentSize;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::GetBufferMaxSize(PRUint32 *aBufferMaxSize)
{
*aBufferMaxSize = mBufferMaxSize;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::SetBufferMaxSize(PRUint32 aBufferMaxSize)
{
mBufferMaxSize = aBufferMaxSize;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::GetLocalFile(nsIFile* *file)
{
nsresult rv;
nsCOMPtr<nsIFileIO> fileIO = do_QueryInterface(mStreamIO, &rv);
if (NS_FAILED(rv)) return rv;
rv = fileIO->GetFile(file);
if (NS_FAILED(rv)) {
*file = nsnull;
}
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::GetPipeliningAllowed(PRBool *aPipeliningAllowed)
{
*aPipeliningAllowed = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::SetPipeliningAllowed(PRBool aPipeliningAllowed)
{
NS_NOTREACHED("SetPipeliningAllowed");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsFileTransport::GetOwner(nsISupports * *aOwner)
{
@@ -1151,6 +1106,7 @@ nsFileTransport::SetNotificationCallbacks(nsIInterfaceRequestor* aNotificationCa
return NS_OK;
}
#endif
NS_IMETHODIMP
nsFileTransport::GetSecurityInfo(nsISupports * *aSecurityInfo)
@@ -1159,4 +1115,34 @@ nsFileTransport::GetSecurityInfo(nsISupports * *aSecurityInfo)
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::GetProgressEventSink(nsIProgressEventSink **aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
NS_IF_ADDREF(*aResult = mProgress);
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::SetProgressEventSink(nsIProgressEventSink *aProgress)
{
mProgress = nsnull;
if (aProgress) {
// Now generate a proxied event sink
nsresult rv;
NS_WITH_SERVICE(nsIProxyObjectManager,
proxyMgr, kProxyObjectManagerCID, &rv);
if (NS_FAILED(rv)) return rv;
rv = proxyMgr->GetProxyForObject(NS_UI_THREAD_EVENTQ, // primordial thread - should change?
NS_GET_IID(nsIProgressEventSink),
aProgress,
PROXY_ASYNC | PROXY_ALWAYS,
getter_AddRefs(mProgress));
}
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////

11
netwerk/base/src/nsFileTransport.h
View File

@@ -23,7 +23,8 @@
#ifndef nsFileTransport_h__
#define nsFileTransport_h__
#include "nsIChannel.h"
#include "nsITransport.h"
#include "nsIRequest.h"
#include "nsIRunnable.h"
#include "nsFileSpec.h"
#include "prlock.h"
@@ -49,13 +50,15 @@ class nsIInterfaceRequestor;
class nsFileTransportSourceWrapper;
class nsFileTransportSinkWrapper;
class nsFileTransport : public nsIChannel,
class nsFileTransport : public nsITransport,
public nsITransportRequest,
public nsIRunnable
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSITRANSPORT
NS_DECL_NSIREQUEST
NS_DECL_NSICHANNEL
NS_DECL_NSITRANSPORTREQUEST
NS_DECL_NSIRUNNABLE
nsFileTransport();
@@ -98,7 +101,6 @@ public:
};
protected:
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsIProgressEventSink> mProgress;
nsCOMPtr<nsIStreamIO> mStreamIO;
char *mContentType;
@@ -125,7 +127,6 @@ protected:
PRUint32 mOffset;
PRInt32 mTotalAmount;
PRInt32 mTransferAmount;
nsLoadFlags mLoadAttributes;
// reading state variables:
nsCOMPtr<nsIStreamListener> mListener;

6
netwerk/base/src/nsFileTransportService.cpp
View File

@@ -88,7 +88,7 @@ NS_IMETHODIMP
nsFileTransportService::CreateTransport(nsIFile* file,
PRInt32 ioFlags,
PRInt32 perm,
nsIChannel** result)
nsITransport** result)
{
nsresult rv;
nsFileTransport* trans = new nsFileTransport();
@@ -109,7 +109,7 @@ nsFileTransportService::CreateTransportFromStream(const char* name,
nsIInputStream *fromStream,
const char* contentType,
PRInt32 contentLength,
nsIChannel** result)
nsITransport** result)
{
nsresult rv;
nsFileTransport* trans = new nsFileTransport();
@@ -127,7 +127,7 @@ nsFileTransportService::CreateTransportFromStream(const char* name,
NS_IMETHODIMP
nsFileTransportService::CreateTransportFromStreamIO(nsIStreamIO *io,
nsIChannel **result)
nsITransport **result)
{
nsresult rv;
nsFileTransport* trans = new nsFileTransport();

34
netwerk/base/src/nsIOService.cpp
View File

@@ -368,40 +368,6 @@ nsIOService::SetOffline(PRBool offline)
}
NS_IMETHODIMP
nsIOService::ConsumeInput(nsIChannel* channel, nsISupports* context,
nsIStreamListener* consumer)
{
nsresult rv;
nsCOMPtr<nsIInputStream> in;
rv = channel->OpenInputStream(getter_AddRefs(in));
if (NS_FAILED(rv)) return rv;
rv = consumer->OnStartRequest(channel, context);
if (NS_FAILED(rv)) return rv;
PRUint32 sourceOffset = 0;
while (1) {
char buf[1024];
PRUint32 readCount;
rv = in->Read(buf, sizeof(buf), &readCount);
if (NS_FAILED(rv))
break;
if (readCount == 0) // eof
break;
rv = consumer->OnDataAvailable(channel, context, 0, sourceOffset, readCount);
sourceOffset += readCount;
if (NS_FAILED(rv))
break;
}
rv = consumer->OnStopRequest(channel, context, rv, nsnull);
if (NS_FAILED(rv)) return rv;
return rv;
}
////////////////////////////////////////////////////////////////////////////////
// URL parsing utilities

301
netwerk/base/src/nsInputStreamChannel.cpp
View File

@@ -170,9 +170,6 @@ nsStreamIOChannel::Init(nsIURI* uri, nsIStreamIO* io)
return NS_OK;
}
NS_IMPL_THREADSAFE_ADDREF(nsStreamIOChannel)
NS_IMPL_THREADSAFE_RELEASE(nsStreamIOChannel)
NS_INTERFACE_MAP_BEGIN(nsStreamIOChannel)
NS_INTERFACE_MAP_ENTRY(nsIStreamIOChannel)
NS_INTERFACE_MAP_ENTRY(nsIChannel)
@@ -183,8 +180,8 @@ NS_INTERFACE_MAP_BEGIN(nsStreamIOChannel)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIStreamListener)
NS_INTERFACE_MAP_END_THREADSAFE
////////////////////////////////////////////////////////////////////////////////
// nsIRequest methods:
NS_IMPL_THREADSAFE_ADDREF(nsStreamIOChannel)
NS_IMPL_THREADSAFE_RELEASE(nsStreamIOChannel)
NS_IMETHODIMP
nsStreamIOChannel::GetName(PRUnichar* *result)
@@ -202,8 +199,8 @@ nsStreamIOChannel::GetName(PRUnichar* *result)
NS_IMETHODIMP
nsStreamIOChannel::IsPending(PRBool *result)
{
if (mFileTransport)
return mFileTransport->IsPending(result);
if (mRequest)
return mRequest->IsPending(result);
*result = PR_FALSE;
return NS_OK;
}
@@ -215,8 +212,8 @@ nsStreamIOChannel::GetStatus(nsresult *status)
// if we don't have a status error of our own to report
// then we should propogate the status error of the underlying
// file transport (if we have one)
if (NS_SUCCEEDED(mStatus) && mFileTransport)
mFileTransport->GetStatus(status);
if (NS_SUCCEEDED(mStatus) && mRequest)
mRequest->GetStatus(status);
return NS_OK;
}
@@ -226,29 +223,30 @@ nsStreamIOChannel::Cancel(nsresult status)
{
NS_ASSERTION(NS_FAILED(status), "shouldn't cancel with a success code");
mStatus = status;
if (mFileTransport)
return mFileTransport->Cancel(status);
if (mRequest)
return mRequest->Cancel(status);
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::Suspend(void)
{
if (mFileTransport)
return mFileTransport->Suspend();
if (mRequest)
return mRequest->Suspend();
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::Resume(void)
{
if (mFileTransport)
return mFileTransport->Resume();
if (mRequest)
return mRequest->Resume();
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsIChannel methods:
// nsIChannel implementation:
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsStreamIOChannel::GetOriginalURI(nsIURI* *aURI)
@@ -281,19 +279,13 @@ nsStreamIOChannel::SetURI(nsIURI* aURI)
}
NS_IMETHODIMP
nsStreamIOChannel::OpenInputStream(nsIInputStream **result)
nsStreamIOChannel::Open(nsIInputStream **result)
{
return mStreamIO->GetInputStream(result);
}
NS_IMETHODIMP
nsStreamIOChannel::OpenOutputStream(nsIOutputStream **result)
{
return mStreamIO->GetOutputStream(result);
}
NS_IMETHODIMP
nsStreamIOChannel::AsyncRead(nsIStreamListener *listener, nsISupports *ctxt)
nsStreamIOChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt)
{
nsresult rv;
@@ -315,7 +307,7 @@ nsStreamIOChannel::AsyncRead(nsIStreamListener *listener, nsISupports *ctxt)
}
}
rv = mLoadGroup->AddChannel(this, nsnull);
rv = mLoadGroup->AddRequest(this, nsnull);
if (NS_FAILED(rv)) return rv;
}
@@ -325,14 +317,6 @@ nsStreamIOChannel::AsyncRead(nsIStreamListener *listener, nsISupports *ctxt)
rv = fts->CreateTransportFromStreamIO(mStreamIO, getter_AddRefs(mFileTransport));
if (NS_FAILED(rv)) goto done;
if (mBufferSegmentSize > 0) {
rv = mFileTransport->SetBufferSegmentSize(mBufferSegmentSize);
if (NS_FAILED(rv)) goto done;
}
if (mBufferMaxSize > 0) {
rv = mFileTransport->SetBufferMaxSize(mBufferMaxSize);
if (NS_FAILED(rv)) goto done;
}
}
#if 0
@@ -341,78 +325,13 @@ nsStreamIOChannel::AsyncRead(nsIStreamListener *listener, nsISupports *ctxt)
if (NS_FAILED(rv)) goto done;
}
#endif
rv = mFileTransport->AsyncRead(this, ctxt);
rv = mFileTransport->AsyncRead(this, ctxt, 0, -1, 0, getter_AddRefs(mRequest));
done:
if (NS_FAILED(rv)) {
nsresult rv2;
rv2 = mLoadGroup->RemoveChannel(this, ctxt, rv, nsnull);
NS_ASSERTION(NS_SUCCEEDED(rv2), "RemoveChannel failed");
// release the transport so that we don't think we're in progress
mFileTransport = nsnull;
}
return rv;
}
NS_IMETHODIMP
nsStreamIOChannel::AsyncWrite(nsIStreamProvider *provider, nsISupports *ctxt)
{
nsresult rv;
NS_ASSERTION(provider, "no provider");
SetProvider(provider);
if (mLoadGroup) {
nsCOMPtr<nsILoadGroupListenerFactory> factory;
//
// Create a load group "proxy" listener...
//
rv = mLoadGroup->GetGroupListenerFactory(getter_AddRefs(factory));
if (factory) {
NS_WARNING("load group proxy listener not implemented for AsyncWrite");
#if 0
nsIStreamListener *newListener;
rv = factory->CreateLoadGroupListener(GetListener(), &newListener);
if (NS_SUCCEEDED(rv)) {
mUserObserver = newListener;
NS_RELEASE(newListener);
}
#endif
}
rv = mLoadGroup->AddChannel(this, nsnull);
if (NS_FAILED(rv)) return rv;
}
if (mFileTransport == nsnull) {
NS_WITH_SERVICE(nsIFileTransportService, fts, kFileTransportServiceCID, &rv);
if (NS_FAILED(rv)) goto done;
rv = fts->CreateTransportFromStreamIO(mStreamIO, getter_AddRefs(mFileTransport));
if (NS_FAILED(rv)) goto done;
if (mBufferSegmentSize > 0) {
rv = mFileTransport->SetBufferSegmentSize(mBufferSegmentSize);
if (NS_FAILED(rv)) goto done;
}
if (mBufferMaxSize > 0) {
rv = mFileTransport->SetBufferMaxSize(mBufferMaxSize);
if (NS_FAILED(rv)) goto done;
}
}
#if 0
if (mContentType == nsnull) {
rv = mStreamIO->Open(&mContentType, &mContentLength);
if (NS_FAILED(rv)) goto done;
}
#endif
rv = mFileTransport->AsyncWrite(this, ctxt);
done:
if (NS_FAILED(rv)) {
nsresult rv2;
rv2 = mLoadGroup->RemoveChannel(this, ctxt, rv, nsnull);
NS_ASSERTION(NS_SUCCEEDED(rv2), "RemoveChannel failed");
rv2 = mLoadGroup->RemoveRequest(this, ctxt, rv, nsnull);
NS_ASSERTION(NS_SUCCEEDED(rv2), "RemoveRequest failed");
// release the transport so that we don't think we're in progress
mFileTransport = nsnull;
}
@@ -433,127 +352,6 @@ nsStreamIOChannel::SetLoadAttributes(nsLoadFlags aLoadAttributes)
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetContentType(char * *aContentType)
{
nsresult rv;
if (mContentType == nsnull) {
rv = mStreamIO->Open(&mContentType, &mContentLength);
if (NS_FAILED(rv)) return rv;
}
*aContentType = nsCRT::strdup(mContentType);
if (*aContentType == nsnull) {
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetContentType(const char *aContentType)
{
mContentType = nsCRT::strdup(aContentType);
if (*aContentType == nsnull) {
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetContentLength(PRInt32 *aContentLength)
{
nsresult rv;
if (mContentType == nsnull) {
rv = mStreamIO->Open(&mContentType, &mContentLength);
if (NS_FAILED(rv)) return rv;
}
*aContentLength = mContentLength;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetContentLength(PRInt32 aContentLength)
{
mContentLength = aContentLength;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetTransferOffset(PRUint32 *aTransferOffset)
{
NS_NOTREACHED("nsStreamIOChannel::GetTransferOffset");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStreamIOChannel::SetTransferOffset(PRUint32 aTransferOffset)
{
NS_NOTREACHED("nsStreamIOChannel::SetTransferOffset");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStreamIOChannel::GetTransferCount(PRInt32 *aTransferCount)
{
NS_NOTREACHED("nsStreamIOChannel::GetTransferCount");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStreamIOChannel::SetTransferCount(PRInt32 aTransferCount)
{
NS_NOTREACHED("nsStreamIOChannel::SetTransferCount");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStreamIOChannel::GetBufferSegmentSize(PRUint32 *aBufferSegmentSize)
{
*aBufferSegmentSize = mBufferSegmentSize;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetBufferSegmentSize(PRUint32 aBufferSegmentSize)
{
mBufferSegmentSize = aBufferSegmentSize;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetBufferMaxSize(PRUint32 *aBufferMaxSize)
{
*aBufferMaxSize = mBufferMaxSize;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetBufferMaxSize(PRUint32 aBufferMaxSize)
{
mBufferMaxSize = aBufferMaxSize;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetLocalFile(nsIFile* *file)
{
*file = nsnull;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetPipeliningAllowed(PRBool *aPipeliningAllowed)
{
*aPipeliningAllowed = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetPipeliningAllowed(PRBool aPipeliningAllowed)
{
NS_NOTREACHED("nsStreamIOChannel::SetPipeliningAllowed");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStreamIOChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
{
@@ -599,7 +397,6 @@ nsStreamIOChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aNotification
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetSecurityInfo(nsISupports * *aSecurityInfo)
{
@@ -607,19 +404,63 @@ nsStreamIOChannel::GetSecurityInfo(nsISupports * *aSecurityInfo)
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetContentType(char * *aContentType)
{
nsresult rv;
if (mContentType == nsnull) {
rv = mStreamIO->Open(&mContentType, &mContentLength);
if (NS_FAILED(rv)) return rv;
}
*aContentType = nsCRT::strdup(mContentType);
if (*aContentType == nsnull) {
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetContentType(const char *aContentType)
{
mContentType = nsCRT::strdup(aContentType);
if (*aContentType == nsnull) {
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetContentLength(PRInt32 *aContentLength)
{
nsresult rv;
if (mContentType == nsnull) {
rv = mStreamIO->Open(&mContentType, &mContentLength);
if (NS_FAILED(rv)) return rv;
}
*aContentLength = mContentLength;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetContentLength(PRInt32 aContentLength)
{
mContentLength = aContentLength;
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsIStreamObserver implementation:
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsStreamIOChannel::OnStartRequest(nsIChannel* transportChannel, nsISupports* context)
nsStreamIOChannel::OnStartRequest(nsIRequest *request, nsISupports* context)
{
NS_ASSERTION(mUserObserver, "No listener...");
return mUserObserver->OnStartRequest(this, context);
}
NS_IMETHODIMP
nsStreamIOChannel::OnStopRequest(nsIChannel* transportChannel, nsISupports* context,
nsStreamIOChannel::OnStopRequest(nsIRequest *request, nsISupports* context,
nsresult aStatus, const PRUnichar* aStatusArg)
{
nsresult rv;
@@ -631,7 +472,7 @@ nsStreamIOChannel::OnStopRequest(nsIChannel* transportChannel, nsISupports* cont
if (mLoadGroup) {
if (NS_SUCCEEDED(rv)) {
rv = mLoadGroup->RemoveChannel(this, context, aStatus, aStatusArg);
rv = mLoadGroup->RemoveRequest(this, context, aStatus, aStatusArg);
if (NS_FAILED(rv)) return rv;
}
}
@@ -648,7 +489,7 @@ nsStreamIOChannel::OnStopRequest(nsIChannel* transportChannel, nsISupports* cont
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsStreamIOChannel::OnDataAvailable(nsIChannel* transportChannel, nsISupports* context,
nsStreamIOChannel::OnDataAvailable(nsIRequest *request, nsISupports* context,
nsIInputStream *aIStream, PRUint32 aSourceOffset,
PRUint32 aLength)
{
@@ -661,9 +502,9 @@ nsStreamIOChannel::OnDataAvailable(nsIChannel* transportChannel, nsISupports* co
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsStreamIOChannel::OnDataWritable(nsIChannel* transportChannel, nsISupports* context,
nsIOutputStream *aOStream, PRUint32 aOffset,
PRUint32 aLength)
nsStreamIOChannel::OnDataWritable(nsIRequest *request, nsISupports *context,
nsIOutputStream *aOStream,
PRUint32 aOffset, PRUint32 aLength)
{
return GetProvider()->OnDataWritable(this, context, aOStream,
aOffset, aLength);

4
netwerk/base/src/nsInputStreamChannel.h
View File

@@ -32,6 +32,7 @@
#include "nsIStreamProvider.h"
#include "nsIInterfaceRequestor.h"
#include "nsIStreamIO.h"
#include "nsITransport.h"
class nsInputStreamIO : public nsIInputStreamIO
{
@@ -90,7 +91,8 @@ protected:
nsCOMPtr<nsIStreamIO> mStreamIO;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsISupports> mOwner;
nsCOMPtr<nsIChannel> mFileTransport;
nsCOMPtr<nsITransport> mFileTransport;
nsCOMPtr<nsIRequest> mRequest;
nsCOMPtr<nsIStreamObserver> mUserObserver;
PRUint32 mBufferSegmentSize;
PRUint32 mBufferMaxSize;

270
netwerk/base/src/nsLoadGroup.cpp
View File

@@ -56,7 +56,7 @@ PRLogModuleInfo* gLoadGroupLog = nsnull;
nsLoadGroup::nsLoadGroup(nsISupports* outer)
: mDefaultLoadAttributes(nsIChannel::LOAD_NORMAL),
mForegroundCount(0),
mChannels(nsnull),
mRequests(nsnull),
mStatus(NS_OK)
{
NS_INIT_AGGREGATED(outer);
@@ -82,8 +82,8 @@ nsLoadGroup::~nsLoadGroup()
rv = Cancel(NS_BINDING_ABORTED);
NS_ASSERTION(NS_SUCCEEDED(rv), "Cancel failed");
NS_IF_RELEASE(mChannels);
mDefaultLoadChannel = null_nsCOMPtr();
NS_IF_RELEASE(mRequests);
mDefaultLoadRequest = null_nsCOMPtr();
PR_LOG(gLoadGroupLog, PR_LOG_DEBUG,
("LOADGROUP [%x]: Destroyed.\n", this));
@@ -92,7 +92,7 @@ nsLoadGroup::~nsLoadGroup()
nsresult nsLoadGroup::Init()
{
return NS_NewISupportsArray(&mChannels);
return NS_NewISupportsArray(&mRequests);
}
@@ -157,19 +157,20 @@ NS_IMETHODIMP
nsLoadGroup::GetName(PRUnichar* *result)
{
// XXX is this the right "name" for a load group?
nsresult rv;
nsXPIDLCString urlStr;
if (mDefaultLoadChannel) {
nsCOMPtr<nsIURI> url;
rv = mDefaultLoadChannel->GetURI(getter_AddRefs(url));
if (NS_FAILED(rv)) return rv;
rv = url->GetSpec(getter_Copies(urlStr));
if (NS_FAILED(rv)) return rv;
}
*result = nsnull;
if (mDefaultLoadRequest) {
nsXPIDLString nameStr;
nsresult rv = mDefaultLoadRequest->GetName(getter_Copies(nameStr));
if (NS_SUCCEEDED(rv)) {
nsString name;
name.AppendWithConversion(urlStr);
name.Assign(nameStr);
*result = name.ToNewUnicode();
return *result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
}
return NS_OK;
}
NS_IMETHODIMP
@@ -187,8 +188,8 @@ nsLoadGroup::IsPending(PRBool *aResult)
NS_IMETHODIMP
nsLoadGroup::GetStatus(nsresult *status)
{
if (NS_SUCCEEDED(mStatus) && mDefaultLoadChannel)
return mDefaultLoadChannel->GetStatus(status);
if (NS_SUCCEEDED(mStatus) && mDefaultLoadRequest)
return mDefaultLoadRequest->GetStatus(status);
*status = mStatus;
return NS_OK;
@@ -206,67 +207,57 @@ nsLoadGroup::Cancel(nsresult status)
mStatus = status;
rv = mChannels->Count(&count);
rv = mRequests->Count(&count);
if (NS_FAILED(rv)) return rv;
firstError = NS_OK;
if (count) {
nsIChannel* channel;
nsIRequest* request;
//
// Operate the elements from back to front so that if items get
// get removed from the list it won't affect our iteration
//
while (count > 0) {
channel = NS_STATIC_CAST(nsIChannel*, mChannels->ElementAt(--count));
request = NS_STATIC_CAST(nsIRequest*, mRequests->ElementAt(--count));
NS_ASSERTION(channel, "NULL channel found in list.");
if (!channel) {
NS_ASSERTION(request, "NULL request found in list.");
if (!request) {
continue;
}
#if defined(PR_LOGGING)
char* uriStr;
nsCOMPtr<nsIURI> uri;
rv = channel->GetURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(rv)) {
rv = uri->GetSpec(&uriStr);
}
if (NS_FAILED(rv)) {
uriStr = nsCRT::strdup("?");
}
nsXPIDLString nameStr;
request->GetName(getter_Copies(nameStr));
PR_LOG(gLoadGroupLog, PR_LOG_DEBUG,
("LOADGROUP [%x]: Canceling channel %x %s.\n",
this, channel, uriStr));
nsCRT::free(uriStr);
("LOADGROUP [%x]: Canceling request %x %s.\n",
this, request, NS_ConvertUCS2toUTF8(nameStr).get()));
#endif /* PR_LOGGING */
//
// Remove the channel from the load group... This may cause
// Remove the request from the load group... This may cause
// the OnStopRequest notification to fire...
//
// XXX: What should the context and error message be?
//
(void)RemoveChannel(channel, nsnull, status, nsnull);
(void)RemoveRequest(request, nsnull, status, nsnull);
// Cancel the channel...
rv = channel->Cancel(status);
// Cancel the request...
rv = request->Cancel(status);
// Remember the first failure and return it...
if (NS_FAILED(rv) && NS_SUCCEEDED(firstError)) {
firstError = rv;
}
NS_RELEASE(channel);
NS_RELEASE(request);
}
#if defined(DEBUG)
(void)mChannels->Count(&count);
(void)mRequests->Count(&count);
NS_ASSERTION(count == 0, "Channel list is not empty.");
NS_ASSERTION(count == 0, "Request list is not empty.");
NS_ASSERTION(mForegroundCount == 0, "Foreground URLs are active.");
#endif /* DEBUG */
}
@@ -282,7 +273,7 @@ nsLoadGroup::Suspend()
nsresult rv, firstError;
PRUint32 count;
rv = mChannels->Count(&count);
rv = mRequests->Count(&count);
if (NS_FAILED(rv)) return rv;
firstError = NS_OK;
@@ -291,42 +282,30 @@ nsLoadGroup::Suspend()
// get removed from the list it won't affect our iteration
//
while (count > 0) {
nsIChannel* channel;
nsIRequest* request = NS_STATIC_CAST(nsIRequest*, mRequests->ElementAt(--count));
channel = NS_STATIC_CAST(nsIChannel*, mChannels->ElementAt(--count));
NS_ASSERTION(channel, "NULL channel found in list.");
if (!channel) {
NS_ASSERTION(request, "NULL request found in list.");
if (!request) {
continue;
}
#if defined(PR_LOGGING)
char* uriStr;
nsCOMPtr<nsIURI> uri;
rv = channel->GetURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(rv)) {
rv = uri->GetSpec(&uriStr);
}
if (NS_FAILED(rv)) {
uriStr = nsCRT::strdup("?");
}
nsXPIDLString nameStr;
request->GetName(getter_Copies(nameStr));
PR_LOG(gLoadGroupLog, PR_LOG_DEBUG,
("LOADGROUP [%x]: Suspending channel %x %s.\n",
this, channel, uriStr));
nsCRT::free(uriStr);
("LOADGROUP [%x]: Suspending request %x %s.\n",
this, request, NS_ConvertUCS2toUTF8(nameStr).get()));
#endif /* PR_LOGGING */
// Suspend the channel...
rv = channel->Suspend();
// Suspend the request...
rv = request->Suspend();
// Remember the first failure and return it...
if (NS_FAILED(rv) && NS_SUCCEEDED(firstError)) {
firstError = rv;
}
NS_RELEASE(channel);
NS_RELEASE(request);
}
return firstError;
@@ -339,7 +318,7 @@ nsLoadGroup::Resume()
nsresult rv, firstError;
PRUint32 count;
rv = mChannels->Count(&count);
rv = mRequests->Count(&count);
if (NS_FAILED(rv)) return rv;
firstError = NS_OK;
@@ -348,42 +327,30 @@ nsLoadGroup::Resume()
// get removed from the list it won't affect our iteration
//
while (count > 0) {
nsIChannel* channel;
nsIRequest* request = NS_STATIC_CAST(nsIRequest*, mRequests->ElementAt(--count));
channel = NS_STATIC_CAST(nsIChannel*, mChannels->ElementAt(--count));
NS_ASSERTION(channel, "NULL channel found in list.");
if (!channel) {
NS_ASSERTION(request, "NULL request found in list.");
if (!request) {
continue;
}
#if defined(PR_LOGGING)
char* uriStr;
nsCOMPtr<nsIURI> uri;
rv = channel->GetURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(rv)) {
rv = uri->GetSpec(&uriStr);
}
if (NS_FAILED(rv)) {
uriStr = nsCRT::strdup("?");
}
nsXPIDLString nameStr;
request->GetName(getter_Copies(nameStr));
PR_LOG(gLoadGroupLog, PR_LOG_DEBUG,
("LOADGROUP [%x]: Resuming channel %x %s.\n",
this, channel, uriStr));
nsCRT::free(uriStr);
("LOADGROUP [%x]: Resuming request %x %s.\n",
this, request, NS_ConvertUCS2toUTF8(nameStr).get()));
#endif /* PR_LOGGING */
// Resume the channel...
rv = channel->Resume();
// Resume the request...
rv = request->Resume();
// Remember the first failure and return it...
if (NS_FAILED(rv) && NS_SUCCEEDED(firstError)) {
firstError = rv;
}
NS_RELEASE(channel);
NS_RELEASE(request);
}
return firstError;
@@ -417,58 +384,46 @@ nsLoadGroup::SetDefaultLoadAttributes(PRUint32 aDefaultLoadAttributes)
}
NS_IMETHODIMP
nsLoadGroup::GetDefaultLoadChannel(nsIChannel * *aChannel)
nsLoadGroup::GetDefaultLoadRequest(nsIRequest * *aRequest)
{
*aChannel = mDefaultLoadChannel;
NS_IF_ADDREF(*aChannel);
*aRequest = mDefaultLoadRequest;
NS_IF_ADDREF(*aRequest);
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::SetDefaultLoadChannel(nsIChannel *aChannel)
nsLoadGroup::SetDefaultLoadRequest(nsIRequest *aRequest)
{
mDefaultLoadChannel = aChannel;
mDefaultLoadRequest = aRequest;
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::AddChannel(nsIChannel *channel, nsISupports* ctxt)
nsLoadGroup::AddRequest(nsIRequest *request, nsISupports* ctxt)
{
nsresult rv;
#if defined(PR_LOGGING)
{
PRUint32 count;
char* uriStr;
nsCOMPtr<nsIURI> uri;
rv = channel->GetURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(rv))
rv = uri->GetSpec(&uriStr);
if (NS_FAILED(rv))
uriStr = nsCRT::strdup("?");
(void)mChannels->Count(&count);
PRUint32 count = 0;
(void)mRequests->Count(&count);
nsXPIDLString nameStr;
request->GetName(getter_Copies(nameStr));
PR_LOG(gLoadGroupLog, PR_LOG_DEBUG,
("LOADGROUP [%x]: Adding channel %x %s (count=%d).\n",
this, channel, uriStr, count));
nsCRT::free(uriStr);
}
("LOADGROUP [%x]: Adding request %x %s (count=%d).\n",
this, request, NS_ConvertUCS2toUTF8(nameStr).get(), count));
#endif /* PR_LOGGING */
nsLoadFlags flags;
MergeLoadAttributes(channel);
rv = channel->GetLoadAttributes(&flags);
rv = MergeLoadAttributes(request, flags);
if (NS_FAILED(rv)) return rv;
//
// Add the channel to the list of active channels...
// Add the request to the list of active requests...
//
// XXX this method incorrectly returns a bool
//
rv = mChannels->AppendElement(channel) ? NS_OK : NS_ERROR_FAILURE;
rv = mRequests->AppendElement(request) ? NS_OK : NS_ERROR_FAILURE;
if (NS_FAILED(rv)) return rv;
if (!(flags & nsIChannel::LOAD_BACKGROUND)) {
@@ -478,28 +433,28 @@ nsLoadGroup::AddChannel(nsIChannel *channel, nsISupports* ctxt)
//
// Fire the OnStartRequest notification out to the observer...
//
// If the notification fails then DO NOT add the channel to
// If the notification fails then DO NOT add the request to
// the load group.
//
nsCOMPtr<nsIStreamObserver> observer (do_QueryReferent(mObserver));
if (observer) {
PR_LOG(gLoadGroupLog, PR_LOG_DEBUG,
("LOADGROUP [%x]: Firing OnStartRequest for channel %x."
("LOADGROUP [%x]: Firing OnStartRequest for request %x."
"(foreground count=%d).\n",
this, channel, mForegroundCount));
this, request, mForegroundCount));
rv = observer->OnStartRequest(channel, ctxt);
rv = observer->OnStartRequest(request, ctxt);
if (NS_FAILED(rv)) {
PR_LOG(gLoadGroupLog, PR_LOG_ERROR,
("LOADGROUP [%x]: OnStartRequest for channel %x FAILED.\n",
this, channel));
("LOADGROUP [%x]: OnStartRequest for request %x FAILED.\n",
this, request));
//
// The URI load has been canceled by the observer. Clean up
// the damage...
//
// XXX this method incorrectly returns a bool
//
rv = mChannels->RemoveElement(channel) ? NS_OK : NS_ERROR_FAILURE;
rv = mRequests->RemoveElement(request) ? NS_OK : NS_ERROR_FAILURE;
mForegroundCount -= 1;
}
}
@@ -509,56 +464,43 @@ nsLoadGroup::AddChannel(nsIChannel *channel, nsISupports* ctxt)
}
NS_IMETHODIMP
nsLoadGroup::RemoveChannel(nsIChannel *channel, nsISupports* ctxt,
nsLoadGroup::RemoveRequest(nsIRequest *request, nsISupports* ctxt,
nsresult aStatus, const PRUnichar* aStatusArg)
{
nsresult rv;
#if defined(PR_LOGGING)
{
PRUint32 count = 0;
char* uriStr;
nsCOMPtr<nsIURI> uri;
if (channel) {
rv = channel->GetURI(getter_AddRefs(uri));
}
else {
rv = NS_ERROR_NULL_POINTER;
}
if (NS_SUCCEEDED(rv))
rv = uri->GetSpec(&uriStr);
if (NS_FAILED(rv))
uriStr = nsCRT::strdup("?");
(void)mChannels->Count(&count);
(void)mRequests->Count(&count);
nsXPIDLString nameStr;
request->GetName(getter_Copies(nameStr));
PR_LOG(gLoadGroupLog, PR_LOG_DEBUG,
("LOADGROUP [%x]: Removing channel %x %s status %x (count=%d).\n",
this, channel, uriStr, aStatus, count-1));
nsCRT::free(uriStr);
}
("LOADGROUP [%x]: Removing request %x %s status %x (count=%d).\n",
this, request, NS_ConvertUCS2toUTF8(nameStr).get(), aStatus, count-1));
#endif /* PR_LOGGING */
//
// Remove the channel from the group. If this fails, it means that
// the channel was *not* in the group so do not update the foreground
// Remove the request from the group. If this fails, it means that
// the request was *not* in the group so do not update the foreground
// count or it will get messed up...
//
//
// XXX this method incorrectly returns a bool
//
rv = mChannels->RemoveElement(channel) ? NS_OK : NS_ERROR_FAILURE;
rv = mRequests->RemoveElement(request) ? NS_OK : NS_ERROR_FAILURE;
if (NS_FAILED(rv)) {
PR_LOG(gLoadGroupLog, PR_LOG_ERROR,
("LOADGROUP [%x]: Unable to remove channel %x. Not in group!\n",
this, channel));
("LOADGROUP [%x]: Unable to remove request %x. Not in group!\n",
this, request));
return rv;
}
nsLoadFlags flags;
rv = channel->GetLoadAttributes(&flags);
nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request, &rv);
if (NS_FAILED(rv))
return NS_ERROR_FAILURE;
rv = aChannel->GetLoadAttributes(&flags);
if (NS_FAILED(rv)) return rv;
if (!(flags & nsIChannel::LOAD_BACKGROUND)) {
@@ -569,15 +511,15 @@ nsLoadGroup::RemoveChannel(nsIChannel *channel, nsISupports* ctxt,
nsCOMPtr<nsIStreamObserver> observer (do_QueryReferent(mObserver));
if (observer) {
PR_LOG(gLoadGroupLog, PR_LOG_DEBUG,
("LOADGROUP [%x]: Firing OnStopRequest for channel %x."
("LOADGROUP [%x]: Firing OnStopRequest for request %x."
"(foreground count=%d).\n",
this, channel, mForegroundCount));
this, request, mForegroundCount));
rv = observer->OnStopRequest(channel, ctxt, aStatus, aStatusArg);
rv = observer->OnStopRequest(request, ctxt, aStatus, aStatusArg);
if (NS_FAILED(rv)) {
PR_LOG(gLoadGroupLog, PR_LOG_ERROR,
("LOADGROUP [%x]: OnStopRequest for channel %x FAILED.\n",
this, channel));
("LOADGROUP [%x]: OnStopRequest for request %x FAILED.\n",
this, request));
}
}
}
@@ -588,9 +530,9 @@ nsLoadGroup::RemoveChannel(nsIChannel *channel, nsISupports* ctxt,
NS_IMETHODIMP
nsLoadGroup::GetChannels(nsISimpleEnumerator * *aChannels)
nsLoadGroup::GetRequests(nsISimpleEnumerator * *aRequests)
{
return NS_NewArrayEnumerator(aChannels, mChannels);
return NS_NewArrayEnumerator(aRequests, mRequests);
}
@@ -659,13 +601,18 @@ nsLoadGroup::GetActiveCount(PRUint32* aResult)
////////////////////////////////////////////////////////////////////////////////
nsresult nsLoadGroup::MergeLoadAttributes(nsIChannel *aChannel)
nsresult nsLoadGroup::MergeLoadAttributes(nsIRequest *aRequest, nsLoadFlags& outFlags)
{
nsresult rv;
nsLoadFlags flags, oldFlags;
nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(aRequest, &rv);
if (NS_FAILED(rv))
return NS_ERROR_FAILURE;
rv = aChannel->GetLoadAttributes(&flags);
if (NS_FAILED(rv)) return rv;
if (NS_FAILED(rv))
return rv;
oldFlags = flags;
//
@@ -707,6 +654,7 @@ nsresult nsLoadGroup::MergeLoadAttributes(nsIChannel *aChannel)
rv = aChannel->SetLoadAttributes(flags);
}
outFlags = flags;
return rv;
}

7
netwerk/base/src/nsLoadGroup.h
View File

@@ -59,20 +59,19 @@ protected:
virtual ~nsLoadGroup();
nsresult Init();
nsresult MergeLoadAttributes(nsIChannel *aChannel);
nsresult MergeLoadAttributes(nsIRequest *aRequest, nsLoadFlags& flags);
protected:
PRUint32 mDefaultLoadAttributes;
PRUint32 mForegroundCount;
nsISupportsArray* mChannels;
nsCOMPtr<nsIRequest> mDefaultLoadRequest;
nsISupportsArray* mRequests;
nsWeakPtr mObserver;
// nsCOMPtr<nsIStreamObserver> mObserver;
nsCOMPtr<nsIChannel> mDefaultLoadChannel;
nsWeakPtr mGroupListenerFactory;
nsresult mStatus;
};

10
netwerk/base/src/nsSimpleStreamListener.cpp
View File

@@ -38,21 +38,21 @@ NS_IMPL_ISUPPORTS3(nsSimpleStreamListener,
//----------------------------------------------------------------------------
//
NS_IMETHODIMP
nsSimpleStreamListener::OnStartRequest(nsIChannel *aChannel,
nsSimpleStreamListener::OnStartRequest(nsIRequest *aRequest,
nsISupports *aContext)
{
return mObserver ?
mObserver->OnStartRequest(aChannel, aContext) : NS_OK;
mObserver->OnStartRequest(aRequest, aContext) : NS_OK;
}
NS_IMETHODIMP
nsSimpleStreamListener::OnStopRequest(nsIChannel *aChannel,
nsSimpleStreamListener::OnStopRequest(nsIRequest* request,
nsISupports *aContext,
nsresult aStatus,
const PRUnichar *aStatusText)
{
return mObserver ?
mObserver->OnStopRequest(aChannel, aContext, aStatus, aStatusText) : NS_OK;
mObserver->OnStopRequest(request, aContext, aStatus, aStatusText) : NS_OK;
}
//
@@ -61,7 +61,7 @@ nsSimpleStreamListener::OnStopRequest(nsIChannel *aChannel,
//----------------------------------------------------------------------------
//
NS_IMETHODIMP
nsSimpleStreamListener::OnDataAvailable(nsIChannel *aChannel,
nsSimpleStreamListener::OnDataAvailable(nsIRequest* request,
nsISupports *aContext,
nsIInputStream *aSource,
PRUint32 aOffset,

10
netwerk/base/src/nsSimpleStreamProvider.cpp
View File

@@ -39,21 +39,21 @@ NS_IMPL_ISUPPORTS3(nsSimpleStreamProvider,
//----------------------------------------------------------------------------
//
NS_IMETHODIMP
nsSimpleStreamProvider::OnStartRequest(nsIChannel *aChannel,
nsSimpleStreamProvider::OnStartRequest(nsIRequest *request,
nsISupports *aContext)
{
return mObserver ?
mObserver->OnStartRequest(aChannel, aContext) : NS_OK;
mObserver->OnStartRequest(request, aContext) : NS_OK;
}
NS_IMETHODIMP
nsSimpleStreamProvider::OnStopRequest(nsIChannel *aChannel,
nsSimpleStreamProvider::OnStopRequest(nsIRequest* request,
nsISupports *aContext,
nsresult aStatus,
const PRUnichar *aStatusText)
{
return mObserver ?
mObserver->OnStopRequest(aChannel, aContext, aStatus, aStatusText) : NS_OK;
mObserver->OnStopRequest(request, aContext, aStatus, aStatusText) : NS_OK;
}
//
@@ -62,7 +62,7 @@ nsSimpleStreamProvider::OnStopRequest(nsIChannel *aChannel,
//----------------------------------------------------------------------------
//
NS_IMETHODIMP
nsSimpleStreamProvider::OnDataWritable(nsIChannel *aChannel,
nsSimpleStreamProvider::OnDataWritable(nsIRequest *request,
nsISupports *aContext,
nsIOutputStream *aOutput,
PRUint32 aOffset,

2579
netwerk/base/src/nsSocketTransport.cpp
View File

File diff suppressed because it is too large Load Diff

273
netwerk/base/src/nsSocketTransport.h
View File

@@ -1,5 +1,4 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
/*
* The contents of this file are subject to the Netscape Public
* License Version 1.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
@@ -29,17 +28,15 @@
#include "prinrval.h"
#include "nsCOMPtr.h"
#include "nsISocketTransport.h"
#include "nsIChannel.h"
#include "nsIInputStream.h"
#include "nsIInputStream.h"
#include "nsIOutputStream.h"
#include "nsIEventQueueService.h"
#include "nsIStreamListener.h"
#include "nsIStreamProvider.h"
#include "nsIDNSListener.h"
#include "nsIDNSService.h"
#include "nsIPipe.h"
#include "nsIProgressEventSink.h"
#include "nsIInterfaceRequestor.h"
#define NS_SOCKET_TRANSPORT_SEGMENT_SIZE (2*1024)
#define NS_SOCKET_TRANSPORT_BUFFER_SIZE (8*1024)
@@ -115,23 +112,23 @@ enum nsSocketReadWriteInfo {
// Forward declarations...
class nsSocketTransportService;
class nsSocketInputStream;
class nsSocketOutputStream;
class nsIInterfaceRequestor;
class nsSocketBS; // base class for blocking streams
class nsSocketBIS; // blocking input stream
class nsSocketBOS; // blocking output stream
class nsSocketIS; // input stream
class nsSocketOS; // output stream
class nsSocketRequest;
class nsSocketReadRequest;
class nsSocketWriteRequest;
class nsSocketTransport : public nsISocketTransport,
public nsIChannel,
public nsIDNSListener,
public nsIInputStreamObserver,
public nsIOutputStreamObserver
public nsIDNSListener
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSITRANSPORT
NS_DECL_NSISOCKETTRANSPORT
NS_DECL_NSIREQUEST
NS_DECL_NSICHANNEL
NS_DECL_NSIINPUTSTREAMOBSERVER
NS_DECL_NSIOUTPUTSTREAMOBSERVER
NS_DECL_NSIDNSLISTENER
// nsSocketTransport methods:
@@ -150,6 +147,8 @@ public:
nsresult Process(PRInt16 aSelectFlags);
nsresult Cancel(nsresult status);
nsresult CheckForTimeout (PRIntervalTime aCurrentTime);
// Close this socket either right away or once done with the transaction.
@@ -165,20 +164,25 @@ public:
PRBool CanBeReused(void) { return
(mCurrentState != eSocketState_Error) && !mCloseConnectionOnceDone;}
//
// request helpers
//
nsresult GetName(PRUnichar **);
nsresult Dispatch(nsSocketRequest *);
nsresult OnProgress(nsSocketRequest *, nsISupports *ctxt, PRUint32 offset);
nsresult OnStatus(nsSocketRequest *, nsISupports *ctxt, nsresult message);
protected:
nsresult doConnection(PRInt16 aSelectFlags);
nsresult doResolveHost(void);
nsresult doRead(PRInt16 aSelectFlags);
nsresult doReadAsync(PRInt16 aSelectFlags);
nsresult doWrite(PRInt16 aSelectFlags);
nsresult doWriteAsync(PRInt16 aSelectFlags);
nsresult doBlockingConnection();
nsresult doReadWrite(PRInt16 aSelectFlags);
nsresult doResolveHost();
nsresult doWriteFromBuffer(PRUint32 *aCount);
nsresult doWriteFromStream(PRUint32 *aCount);
nsresult OnStatus(nsresult message); // with either request
nsresult fireStatus(PRUint32 aCode);
void CompleteAsyncRead();
void CompleteAsyncWrite();
private:
PRIntervalTime mSocketTimeout;
PRIntervalTime mSocketConnectTimeout;
@@ -206,70 +210,233 @@ private:
mReadWriteState &= ~aFlag;
}
PRBool mOnStartWriteFired;
PRBool mOnStartReadFired;
protected:
nsresult mCancelStatus;
PRBool mCloseConnectionOnceDone;
nsSocketState mCurrentState;
nsCOMPtr<nsIRequest> mDNSRequest;
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsIProgressEventSink> mEventSink;
char* mHostName;
PRInt32 mPort;
PRIntervalTime mLastActiveTime;
PRCList mListLink;
PRUint32 mLoadAttributes;
PRMonitor* mMonitor;
PRNetAddr mNetAddress;
nsSocketOperation mOperation;
nsCOMPtr<nsISupports> mOwner;
nsCOMPtr<nsISupports> mSecurityInfo;
PRInt32 mProxyPort;
char* mProxyHost;
PRBool mProxyTransparent;
PRBool mSSLProxy;
PRPackedBool mProxyTransparent;
PRPackedBool mSSLProxy;
nsSocketTransportService* mService;
PRUint32 mReadWriteState;
PRInt16 mSelectFlags;
nsresult mStatus;
PRInt32 mSuspendCount;
PRFileDesc* mSocketFD;
PRUint32 mSocketTypeCount;
char* *mSocketTypes;
nsCOMPtr<nsIStreamListener> mReadListener;
nsCOMPtr<nsISupports> mReadContext;
PRUint32 mReadOffset;
nsCOMPtr<nsIStreamProvider> mWriteProvider;
nsCOMPtr<nsISupports> mWriteContext;
PRUint32 mWriteOffset;
PRInt32 mWriteCount;
PRInt32 mBytesExpected;
PRUint32 mReuseCount;
PRUint32 mLastReuseCount;
nsSocketInputStream *mSocketInputStream;
nsSocketOutputStream *mSocketOutputStream;
nsCOMPtr<nsIInputStream> mReadPipeIn;
nsCOMPtr<nsIOutputStream> mReadPipeOut;
nsCOMPtr<nsIInputStream> mWritePipeIn;
nsCOMPtr<nsIOutputStream> mWritePipeOut;
PRUint32 mBufferSegmentSize;
PRUint32 mBufferMaxSize;
PRUint32 mIdleTimeoutInSeconds;
PRBool mWasConnected;
nsSocketBIS *mBIS;
nsSocketBOS *mBOS;
nsSocketReadRequest *mReadRequest;
nsSocketWriteRequest *mWriteRequest;
PRPackedBool mCloseConnectionOnceDone;
PRPackedBool mWasConnected;
};
/**
* base blocking stream ...
*/
class nsSocketBS
{
public:
nsSocketBS();
virtual ~nsSocketBS();
void SetTransport(nsSocketTransport *);
void SetSocket(PRFileDesc *aSock) { mSock = aSock; }
nsresult Poll(PRInt16 event);
protected:
nsSocketTransport *mTransport;
PRFileDesc *mSock;
};
/**
* blocking input stream, returned by nsITransport::OpenInputStream()
*/
class nsSocketBIS : public nsSocketBS
, public nsIInputStream
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIINPUTSTREAM
nsSocketBIS();
virtual ~nsSocketBIS();
};
/**
* blocking output stream, returned by nsITransport::OpenOutputStream()
*/
class nsSocketBOS : public nsSocketBS
, public nsIOutputStream
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAM
nsSocketBOS();
virtual ~nsSocketBOS();
};
/**
* input stream, passed to nsIStreamListener::OnDataAvailable()
*/
class nsSocketIS : public nsIInputStream
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIINPUTSTREAM
nsSocketIS();
virtual ~nsSocketIS() { }
void SetSocket(PRFileDesc *aSock) { mSock = aSock; }
PRUint32 GetOffset() { return mOffset; }
void SetOffset(PRUint32 o) { mOffset = o; }
PRBool GotWouldBlock() { return mError == PR_WOULD_BLOCK_ERROR; }
PRBool GotError() { return mError != 0; }
PRErrorCode GetError() { return mError; }
private:
PRUint32 mOffset;
PRFileDesc *mSock;
PRErrorCode mError;
};
/**
* output stream, passed to nsIStreamProvider::OnDataWritable()
*/
class nsSocketOS : public nsIOutputStream
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAM
nsSocketOS();
virtual ~nsSocketOS() { }
void SetSocket(PRFileDesc *aSock) { mSock = aSock; }
PRUint32 GetOffset() { return mOffset; }
void SetOffset(PRUint32 o) { mOffset = o; }
PRBool GotWouldBlock() { return mError == PR_WOULD_BLOCK_ERROR; }
PRBool GotError() { return mError != 0; }
PRErrorCode GetError() { return mError; }
private:
PRUint32 mOffset;
PRFileDesc *mSock;
PRErrorCode mError;
};
/**
* base request
*/
class nsSocketRequest : public nsITransportRequest
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIREQUEST
NS_DECL_NSITRANSPORTREQUEST
nsSocketRequest();
virtual ~nsSocketRequest();
PRBool IsSuspended() { return mSuspendCount > 0; }
PRBool IsCanceled() { return mCanceled; }
void SetTransport(nsSocketTransport *);
void SetStatus(nsresult status) { mStatus = status; }
virtual nsISupports *GetContext() = 0;
virtual nsresult OnStart() = 0;
virtual nsresult OnStop() = 0;
protected:
nsresult OnStart(nsIStreamObserver *, nsISupports *);
nsresult OnStop(nsIStreamObserver *, nsISupports *);
nsSocketTransport *mTransport;
nsresult mStatus;
PRIntn mSuspendCount;
PRPackedBool mCanceled;
PRPackedBool mStartFired;
};
/**
* read request, returned by nsITransport::AsyncRead()
*/
class nsSocketReadRequest : public nsSocketRequest
{
public:
nsSocketReadRequest();
virtual ~nsSocketReadRequest();
void SetSocket(PRFileDesc *);
void SetListener(nsIStreamListener *l) { mListener = l; }
void SetListenerContext(nsISupports *c) { mListenerContext = c; }
nsISupports *GetContext() { return mListenerContext; }
nsresult OnStart() { return nsSocketRequest::OnStart(mListener, mListenerContext); }
nsresult OnStop() { return nsSocketRequest::OnStop(mListener, mListenerContext); }
nsresult OnRead();
private:
nsSocketIS *mInputStream;
nsCOMPtr<nsIStreamListener> mListener;
nsCOMPtr<nsISupports> mListenerContext;
};
/**
* write request, returned by nsITransport::AsyncWrite()
*/
class nsSocketWriteRequest : public nsSocketRequest
{
public:
nsSocketWriteRequest();
virtual ~nsSocketWriteRequest();
void SetSocket(PRFileDesc *);
void SetProvider(nsIStreamProvider *p) { mProvider = p; }
void SetProviderContext(nsISupports *c) { mProviderContext = c; }
nsISupports *GetContext() { return mProviderContext; }
nsresult OnStart() { return nsSocketRequest::OnStart(mProvider, mProviderContext); }
nsresult OnStop() { return nsSocketRequest::OnStop(mProvider, mProviderContext); }
nsresult OnWrite();
private:
nsSocketOS *mOutputStream;
nsCOMPtr<nsIStreamProvider> mProvider;
nsCOMPtr<nsISupports> mProviderContext;
};
#endif /* nsSocketTransport_h___ */

12
netwerk/base/src/nsSocketTransportService.cpp
View File

@@ -283,7 +283,7 @@ nsresult nsSocketTransportService::AddToSelectList(nsSocketTransport* aTransport
}
// Initialize/update the info in the entry...
pfd = &mSelectFDSet[i];
pfd->fd = aTransport->GetSocket();;
pfd->fd = aTransport->GetSocket();
pfd->in_flags = aTransport->GetSelectFlags();
pfd->out_flags = 0;
// Add the FileDesc to the PRPollDesc list...
@@ -499,7 +499,7 @@ nsSocketTransportService::CreateTransport(const char* aHost,
PRInt32 proxyPort,
PRUint32 bufferSegmentSize,
PRUint32 bufferMaxSize,
nsIChannel** aResult)
nsITransport** aResult)
{
return CreateTransportOfTypes(0, nsnull, aHost, aPort, proxyHost, proxyPort,
bufferSegmentSize, bufferMaxSize, aResult);
@@ -513,7 +513,7 @@ nsSocketTransportService::CreateTransportOfType(const char* aSocketType,
PRInt32 proxyPort,
PRUint32 bufferSegmentSize,
PRUint32 bufferMaxSize,
nsIChannel** aResult)
nsITransport** aResult)
{
const char * types[] = { aSocketType };
return CreateTransportOfTypes(1, types, aHost, aPort, proxyHost, proxyPort,
@@ -529,7 +529,7 @@ nsSocketTransportService::CreateTransportOfTypes(PRUint32 socketTypeCount,
PRInt32 proxyPort,
PRUint32 bufferSegmentSize,
PRUint32 bufferMaxSize,
nsIChannel** aResult)
nsITransport** aResult)
{
nsresult rv = NS_OK;
@@ -572,7 +572,7 @@ nsSocketTransportService::CreateTransportOfTypes(PRUint32 socketTypeCount,
}
NS_IMETHODIMP
nsSocketTransportService::ReuseTransport(nsIChannel* i_Transport,
nsSocketTransportService::ReuseTransport(nsITransport* i_Transport,
PRBool * o_Reuse)
{
nsresult rv = NS_ERROR_FAILURE;
@@ -590,7 +590,7 @@ nsSocketTransportService::ReuseTransport(nsIChannel* i_Transport,
*/
NS_IMETHODIMP
nsSocketTransportService::Wakeup (nsIChannel* i_Transport)
nsSocketTransportService::Wakeup (nsITransport* i_Transport)
{
nsSocketTransport *transport = NS_STATIC_CAST (nsSocketTransport *, i_Transport);

86
netwerk/base/src/nsStreamListenerProxy.cpp
View File

@@ -35,17 +35,17 @@
//----------------------------------------------------------------------------
// Design Overview
//
// A stream listener proxy maintains a pipe. When the channel makes data
// A stream listener proxy maintains a pipe. When the request makes data
// available, the proxy copies as much of that data as possible into the pipe.
// If data was written to the pipe, then the proxy posts an asynchronous event
// corresponding to the amount of data written. If no data could be written,
// because the pipe was full, then WOULD_BLOCK is returned to the channel,
// indicating that the channel should suspend itself.
// because the pipe was full, then WOULD_BLOCK is returned to the request,
// indicating that the request should suspend itself.
//
// Once suspended in this manner, the channel is only resumed when the pipe is
// Once suspended in this manner, the request is only resumed when the pipe is
// emptied.
//
// XXX The current design does NOT allow the channel to be "externally"
// XXX The current design does NOT allow the request to be "externally"
// suspended!! For the moment this is not a problem, but it should be fixed.
//----------------------------------------------------------------------------
//
@@ -86,11 +86,11 @@ class nsOnDataAvailableEvent : public nsStreamObserverEvent
{
public:
nsOnDataAvailableEvent(nsStreamProxyBase *aProxy,
nsIChannel *aChannel,
nsIRequest *aRequest,
nsISupports *aContext,
nsIInputStream *aSource,
PRUint32 aOffset)
: nsStreamObserverEvent(aProxy, aChannel, aContext)
: nsStreamObserverEvent(aProxy, aRequest, aContext)
, mSource(aSource)
, mOffset(aOffset)
{
@@ -112,33 +112,33 @@ protected:
NS_IMETHODIMP
nsOnDataAvailableEvent::HandleEvent()
{
LOG(("nsOnDataAvailableEvent: HandleEvent [event=%x, chan=%x]", this, mChannel.get()));
LOG(("nsOnDataAvailableEvent: HandleEvent [event=%x, chan=%x]", this, mRequest.get()));
nsStreamListenerProxy *listenerProxy =
NS_STATIC_CAST(nsStreamListenerProxy *, mProxy);
if (NS_FAILED(listenerProxy->GetListenerStatus())) {
LOG(("nsOnDataAvailableEvent: Discarding event [listener_status=%x, chan=%x]\n",
listenerProxy->GetListenerStatus(), mChannel.get()));
listenerProxy->GetListenerStatus(), mRequest.get()));
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsIStreamListener> listener = listenerProxy->GetListener();
if (!listener) {
LOG(("nsOnDataAvailableEvent: Already called OnStopRequest (listener is NULL), [chan=%x]\n",
mChannel.get()));
mRequest.get()));
return NS_ERROR_FAILURE;
}
nsresult status = NS_OK;
nsresult rv = mChannel->GetStatus(&status);
nsresult rv = mRequest->GetStatus(&status);
NS_ASSERTION(NS_SUCCEEDED(rv), "GetStatus failed");
//
// We should only forward this event to the listener if the channel is
// We should only forward this event to the listener if the request is
// still in a "good" state. Because these events are being processed
// asynchronously, there is a very real chance that the listener might
// have cancelled the channel after _this_ event was triggered.
// have cancelled the request after _this_ event was triggered.
//
if (NS_SUCCEEDED(status)) {
//
@@ -152,21 +152,21 @@ nsOnDataAvailableEvent::HandleEvent()
mSource->Available(&avail);
LOG(("nsOnDataAvailableEvent: Calling the consumer's OnDataAvailable "
"[offset=%u count=%u avail=%u chan=%x]\n",
mOffset, count, avail, mChannel.get()));
mOffset, count, avail, mRequest.get()));
}
#endif
// Forward call to listener
rv = listener->OnDataAvailable(mChannel, mContext, mSource, mOffset, count);
rv = listener->OnDataAvailable(mRequest, mContext, mSource, mOffset, count);
LOG(("nsOnDataAvailableEvent: Done with the consumer's OnDataAvailable "
"[rv=%x, chan=%x]\n",
rv, mChannel.get()));
rv, mRequest.get()));
//
// XXX Need to suspend the underlying channel... must consider
// XXX Need to suspend the underlying request... must consider
// other pending events (such as OnStopRequest). These
// should not be forwarded to the listener if the channel
// should not be forwarded to the listener if the request
// is suspended. Also, handling the Resume could be tricky.
//
if (rv == NS_BASE_STREAM_WOULD_BLOCK) {
@@ -182,7 +182,7 @@ nsOnDataAvailableEvent::HandleEvent()
}
else
LOG(("nsOnDataAvailableEvent: Not calling OnDataAvailable [chan=%x]",
mChannel.get()));
mRequest.get()));
return NS_OK;
}
@@ -203,15 +203,15 @@ NS_IMPL_ISUPPORTS_INHERITED3(nsStreamListenerProxy,
//----------------------------------------------------------------------------
//
NS_IMETHODIMP
nsStreamListenerProxy::OnStartRequest(nsIChannel *aChannel,
nsStreamListenerProxy::OnStartRequest(nsIRequest *aRequest,
nsISupports *aContext)
{
return nsStreamProxyBase::OnStartRequest(aChannel, aContext);
return nsStreamProxyBase::OnStartRequest(aRequest, aContext);
}
NS_IMETHODIMP
nsStreamListenerProxy::OnStopRequest(nsIChannel *aChannel,
nsStreamListenerProxy::OnStopRequest(nsIRequest *aRequest,
nsISupports *aContext,
nsresult aStatus,
const PRUnichar *aStatusText)
@@ -222,7 +222,7 @@ nsStreamListenerProxy::OnStopRequest(nsIChannel *aChannel,
mPipeIn = 0;
mPipeOut = 0;
return nsStreamProxyBase::OnStopRequest(aChannel, aContext,
return nsStreamProxyBase::OnStopRequest(aRequest, aContext,
aStatus, aStatusText);
}
@@ -232,7 +232,7 @@ nsStreamListenerProxy::OnStopRequest(nsIChannel *aChannel,
//----------------------------------------------------------------------------
//
NS_IMETHODIMP
nsStreamListenerProxy::OnDataAvailable(nsIChannel *aChannel,
nsStreamListenerProxy::OnDataAvailable(nsIRequest *aRequest,
nsISupports *aContext,
nsIInputStream *aSource,
PRUint32 aOffset,
@@ -242,9 +242,9 @@ nsStreamListenerProxy::OnDataAvailable(nsIChannel *aChannel,
PRUint32 bytesWritten=0;
LOG(("nsStreamListenerProxy: OnDataAvailable [offset=%u count=%u chan=%x]\n",
aOffset, aCount, aChannel));
aOffset, aCount, aRequest));
NS_PRECONDITION(mChannelToResume == 0, "Unexpected call to OnDataAvailable");
NS_PRECONDITION(mRequestToResume == 0, "Unexpected call to OnDataAvailable");
NS_PRECONDITION(mPipeIn, "Pipe not initialized");
NS_PRECONDITION(mPipeOut, "Pipe not initialized");
@@ -254,7 +254,7 @@ nsStreamListenerProxy::OnDataAvailable(nsIChannel *aChannel,
{
nsresult status = mListenerStatus;
if (NS_FAILED(status)) {
LOG(("nsStreamListenerProxy: Listener failed [status=%x chan=%x]\n", status, aChannel));
LOG(("nsStreamListenerProxy: Listener failed [status=%x chan=%x]\n", status, aRequest));
return status;
}
}
@@ -265,29 +265,29 @@ nsStreamListenerProxy::OnDataAvailable(nsIChannel *aChannel,
// Try to copy data into the pipe.
//
// If the pipe is full, then we return NS_BASE_STREAM_WOULD_BLOCK
// so the calling channel can suspend itself. If, however, we detect
// so the calling request can suspend itself. If, however, we detect
// that the pipe was emptied during this time, we retry copying data
// into the pipe.
//
rv = mPipeOut->WriteFrom(aSource, aCount, &bytesWritten);
LOG(("nsStreamListenerProxy: Wrote data to pipe [rv=%x count=%u bytesWritten=%u chan=%x]\n",
rv, aCount, bytesWritten, aChannel));
rv, aCount, bytesWritten, aRequest));
if (NS_FAILED(rv)) {
if (rv == NS_BASE_STREAM_WOULD_BLOCK) {
nsAutoLock lock(mLock);
if (mPipeEmptied) {
LOG(("nsStreamListenerProxy: Pipe emptied; looping back [chan=%x]\n", aChannel));
LOG(("nsStreamListenerProxy: Pipe emptied; looping back [chan=%x]\n", aRequest));
continue;
}
LOG(("nsStreamListenerProxy: Pipe full; setting channel to resume [chan=%x]\n", aChannel));
mChannelToResume = aChannel;
LOG(("nsStreamListenerProxy: Pipe full; setting request to resume [chan=%x]\n", aRequest));
mRequestToResume = aRequest;
}
return rv;
}
if (bytesWritten == 0) {
LOG(("nsStreamListenerProxy: Copied zero bytes; not posting an event [chan=%x]\n", aChannel));
LOG(("nsStreamListenerProxy: Copied zero bytes; not posting an event [chan=%x]\n", aRequest));
return NS_OK;
}
@@ -301,7 +301,7 @@ nsStreamListenerProxy::OnDataAvailable(nsIChannel *aChannel,
PRUint32 total = PR_AtomicAdd((PRInt32 *) &mPendingCount, bytesWritten);
if (total > bytesWritten) {
LOG(("nsStreamListenerProxy: Piggy-backing pending event [total=%u, chan=%x]\n",
total, aChannel));
total, aRequest));
return NS_OK;
}
@@ -309,7 +309,7 @@ nsStreamListenerProxy::OnDataAvailable(nsIChannel *aChannel,
// Post an event for the number of bytes actually written.
//
nsOnDataAvailableEvent *ev =
new nsOnDataAvailableEvent(this, aChannel, aContext, mPipeIn, aOffset);
new nsOnDataAvailableEvent(this, aRequest, aContext, mPipeIn, aOffset);
if (!ev) return NS_ERROR_OUT_OF_MEMORY;
rv = ev->FireEvent(GetEventQueue());
@@ -374,23 +374,23 @@ nsStreamListenerProxy::OnEmpty(nsIInputStream *aInputStream)
{
LOG(("nsStreamListenerProxy: OnEmpty\n"));
//
// The pipe has been emptied by the listener. If the channel
// The pipe has been emptied by the listener. If the request
// has been suspended (waiting for the pipe to be emptied), then
// go ahead and resume it. But take care not to resume while
// holding the "ChannelToResume" lock.
//
nsCOMPtr<nsIChannel> chan;
nsCOMPtr<nsIRequest> req;
{
nsAutoLock lock(mLock);
if (mChannelToResume) {
chan = mChannelToResume;
mChannelToResume = 0;
if (mRequestToResume) {
req = mRequestToResume;
mRequestToResume = 0;
}
mPipeEmptied = PR_TRUE; // Flag this call
}
if (chan) {
LOG(("nsStreamListenerProxy: Resuming channel\n"));
chan->Resume();
if (req) {
LOG(("nsStreamListenerProxy: Resuming request\n"));
req->Resume();
}
return NS_OK;
}

2
netwerk/base/src/nsStreamListenerProxy.h
View File

@@ -42,7 +42,7 @@ public:
protected:
nsCOMPtr<nsIInputStream> mPipeIn;
nsCOMPtr<nsIOutputStream> mPipeOut;
nsCOMPtr<nsIChannel> mChannelToResume;
nsCOMPtr<nsIRequest> mRequestToResume;
PRLock *mLock;
PRUint32 mPendingCount;
PRBool mPipeEmptied;

21
netwerk/base/src/nsStreamLoader.cpp
View File

@@ -35,16 +35,14 @@ nsStreamLoader::Init(nsIURI* aURL,
nsISupports* context,
nsILoadGroup* aGroup,
nsIInterfaceRequestor* notificationCallbacks,
nsLoadFlags loadAttributes,
PRUint32 bufferSegmentSize,
PRUint32 bufferMaxSize)
nsLoadFlags loadAttributes)
{
nsresult rv = NS_OK;
mObserver = observer;
mContext = context;
rv = NS_OpenURI(this, nsnull, aURL, nsnull, aGroup, notificationCallbacks,
loadAttributes, bufferSegmentSize, bufferMaxSize);
loadAttributes);
if (NS_FAILED(rv) && mObserver) {
// don't callback synchronously as it puts the caller
// in a recursive situation and breaks the asynchronous
@@ -96,26 +94,27 @@ nsStreamLoader::GetNumBytesRead(PRUint32* aNumBytes)
return NS_OK;
}
/* readonly attribute nsIRequest request; */
NS_IMETHODIMP
nsStreamLoader::GetChannel(nsIChannel** aChannel)
nsStreamLoader::GetRequest(nsIRequest * *aRequest)
{
*aChannel = mChannel.get();
NS_IF_ADDREF(*aChannel);
NS_IF_ADDREF(*aRequest=mRequest);
return NS_OK;
}
NS_IMETHODIMP
nsStreamLoader::OnStartRequest(nsIChannel* channel, nsISupports *ctxt)
nsStreamLoader::OnStartRequest(nsIRequest* request, nsISupports *ctxt)
{
return NS_OK;
}
NS_IMETHODIMP
nsStreamLoader::OnStopRequest(nsIChannel* channel, nsISupports *ctxt,
nsStreamLoader::OnStopRequest(nsIRequest* request, nsISupports *ctxt,
nsresult aStatus, const PRUnichar* aStatusArg)
{
nsresult rv;
mChannel = channel;
mRequest = request;
rv = mObserver->OnStreamComplete(this, mContext, aStatus,
mData.Length(),
mData.GetBuffer());
@@ -125,7 +124,7 @@ nsStreamLoader::OnStopRequest(nsIChannel* channel, nsISupports *ctxt,
#define BUF_SIZE 1024
NS_IMETHODIMP
nsStreamLoader::OnDataAvailable(nsIChannel* channel, nsISupports *ctxt,
nsStreamLoader::OnDataAvailable(nsIRequest* request, nsISupports *ctxt,
nsIInputStream *inStr,
PRUint32 sourceOffset, PRUint32 count)
{

2
netwerk/base/src/nsStreamLoader.h
View File

@@ -47,7 +47,7 @@ protected:
nsCOMPtr<nsIStreamLoaderObserver> mObserver;
nsCOMPtr<nsISupports> mContext; // the observer's context
nsCString mData;
nsCOMPtr<nsIChannel> mChannel;
nsCOMPtr<nsIRequest> mRequest;
/// nsCOMPtr<nsILoadGroup> mLoadGroup;
};

38
netwerk/base/src/nsStreamObserverProxy.cpp
View File

@@ -39,10 +39,10 @@ static NS_DEFINE_CID(kEventQueueService, NS_EVENTQUEUESERVICE_CID);
//----------------------------------------------------------------------------
//
nsStreamObserverEvent::nsStreamObserverEvent(nsStreamProxyBase *aProxy,
nsIChannel *aChannel,
nsIRequest *aRequest,
nsISupports *aContext)
: mProxy(aProxy)
, mChannel(aChannel)
, mRequest(aRequest)
, mContext(aContext)
{
NS_IF_ADDREF(mProxy);
@@ -94,9 +94,9 @@ class nsOnStartRequestEvent : public nsStreamObserverEvent
{
public:
nsOnStartRequestEvent(nsStreamProxyBase *aProxy,
nsIChannel *aChannel,
nsIRequest *aRequest,
nsISupports *aContext)
: nsStreamObserverEvent(aProxy, aChannel, aContext)
: nsStreamObserverEvent(aProxy, aRequest, aContext)
{
MOZ_COUNT_CTOR(nsOnStartRequestEvent);
}
@@ -112,8 +112,8 @@ public:
NS_IMETHODIMP
nsOnStartRequestEvent::HandleEvent()
{
LOG(("nsOnStartRequestEvent: HandleEvent [event=%x chan=%x]\n",
this, mChannel.get()));
LOG(("nsOnStartRequestEvent: HandleEvent [event=%x req=%x]\n",
this, mRequest.get()));
nsCOMPtr<nsIStreamObserver> observer = mProxy->GetReceiver();
if (!observer) {
@@ -121,7 +121,7 @@ nsOnStartRequestEvent::HandleEvent()
return NS_ERROR_FAILURE;
}
return observer->OnStartRequest(mChannel, mContext);
return observer->OnStartRequest(mRequest, mContext);
}
//
@@ -133,9 +133,9 @@ class nsOnStopRequestEvent : public nsStreamObserverEvent
{
public:
nsOnStopRequestEvent(nsStreamProxyBase *aProxy,
nsIChannel *aChannel, nsISupports *aContext,
nsIRequest *aRequest, nsISupports *aContext,
nsresult aStatus, const PRUnichar *aStatusText)
: nsStreamObserverEvent(aProxy, aChannel, aContext)
: nsStreamObserverEvent(aProxy, aRequest, aContext)
, mStatus(aStatus)
, mStatusText(aStatusText)
{
@@ -157,8 +157,8 @@ protected:
NS_IMETHODIMP
nsOnStopRequestEvent::HandleEvent()
{
LOG(("nsOnStopRequestEvent: HandleEvent [event=%x chan=%x]\n",
this, mChannel.get()));
LOG(("nsOnStopRequestEvent: HandleEvent [event=%x req=%x]\n",
this, mRequest.get()));
nsCOMPtr<nsIStreamObserver> observer = mProxy->GetReceiver();
if (!observer) {
@@ -171,7 +171,7 @@ nsOnStopRequestEvent::HandleEvent()
//
mProxy->SetReceiver(nsnull);
return observer->OnStopRequest(mChannel,
return observer->OnStopRequest(mRequest,
mContext,
mStatus,
mStatusText.GetUnicode());
@@ -191,12 +191,12 @@ NS_IMPL_THREADSAFE_ISUPPORTS1(nsStreamProxyBase,
//----------------------------------------------------------------------------
//
NS_IMETHODIMP
nsStreamProxyBase::OnStartRequest(nsIChannel *aChannel,
nsStreamProxyBase::OnStartRequest(nsIRequest *aRequest,
nsISupports *aContext)
{
LOG(("nsStreamProxyBase: OnStartRequest [this=%x chan=%x]\n", this, aChannel));
LOG(("nsStreamProxyBase: OnStartRequest [this=%x req=%x]\n", this, aRequest));
nsOnStartRequestEvent *ev =
new nsOnStartRequestEvent(this, aChannel, aContext);
new nsOnStartRequestEvent(this, aRequest, aContext);
if (!ev)
return NS_ERROR_OUT_OF_MEMORY;
@@ -207,15 +207,15 @@ nsStreamProxyBase::OnStartRequest(nsIChannel *aChannel,
}
NS_IMETHODIMP
nsStreamProxyBase::OnStopRequest(nsIChannel *aChannel,
nsStreamProxyBase::OnStopRequest(nsIRequest *aRequest,
nsISupports *aContext,
nsresult aStatus,
const PRUnichar *aStatusText)
{
LOG(("nsStreamProxyBase: OnStopRequest [this=%x chan=%x status=%x]\n",
this, aChannel, aStatus));
LOG(("nsStreamProxyBase: OnStopRequest [this=%x req=%x status=%x]\n",
this, aRequest, aStatus));
nsOnStopRequestEvent *ev =
new nsOnStopRequestEvent(this, aChannel, aContext, aStatus, aStatusText);
new nsOnStopRequestEvent(this, aRequest, aContext, aStatus, aStatusText);
if (!ev)
return NS_ERROR_OUT_OF_MEMORY;

4
netwerk/base/src/nsStreamObserverProxy.h
View File

@@ -70,7 +70,7 @@ class nsStreamObserverEvent
{
public:
nsStreamObserverEvent(nsStreamProxyBase *proxy,
nsIChannel *channel, nsISupports *context);
nsIRequest *request, nsISupports *context);
virtual ~nsStreamObserverEvent();
nsresult FireEvent(nsIEventQueue *);
@@ -82,7 +82,7 @@ protected:
PLEvent mEvent;
nsStreamProxyBase *mProxy;
nsCOMPtr<nsIChannel> mChannel;
nsCOMPtr<nsIRequest> mRequest;
nsCOMPtr<nsISupports> mContext;
};

42
netwerk/base/src/nsStreamProviderProxy.cpp
View File

@@ -33,12 +33,12 @@
// Design Overview
//
// A stream provider proxy maintains a pipe. When requested to provide data
// to the channel, whatever data is in the pipe (up to the amount requested)
// is provided to the channel. If there is no data in the pipe, then the
// to the request, whatever data is in the pipe (up to the amount requested)
// is provided to the request. If there is no data in the pipe, then the
// proxy posts an asynchronous event for more data, and returns WOULD_BLOCK
// indicating that the channel should suspend itself.
// indicating that the request should suspend itself.
//
// The channel is only resumed once the event has been successfully handled;
// The request is only resumed once the event has been successfully handled;
// meaning that data has been written to the pipe.
//----------------------------------------------------------------------------
//
@@ -59,12 +59,12 @@ class nsOnDataWritableEvent : public nsStreamObserverEvent
{
public:
nsOnDataWritableEvent(nsStreamProxyBase *aProxy,
nsIChannel *aChannel,
nsIRequest *aRequest,
nsISupports *aContext,
nsIOutputStream *aSink,
PRUint32 aOffset,
PRUint32 aCount)
: nsStreamObserverEvent(aProxy, aChannel, aContext)
: nsStreamObserverEvent(aProxy, aRequest, aContext)
, mSink(aSink)
, mOffset(aOffset)
, mCount(aCount)
@@ -89,7 +89,7 @@ NS_IMETHODIMP
nsOnDataWritableEvent::HandleEvent()
{
LOG(("nsOnDataWritableEvent: HandleEvent [event=%x chan=%x]",
this, mChannel.get()));
this, mRequest.get()));
nsStreamProviderProxy *providerProxy =
NS_STATIC_CAST(nsStreamProviderProxy *, mProxy);
@@ -101,18 +101,18 @@ nsOnDataWritableEvent::HandleEvent()
}
nsresult status = NS_OK;
nsresult rv = mChannel->GetStatus(&status);
nsresult rv = mRequest->GetStatus(&status);
NS_ASSERTION(NS_SUCCEEDED(rv), "GetStatus failed");
//
// We should only forward this event to the provider if the channel is
// We should only forward this event to the provider if the request is
// still in a "good" state. Because these events are being processed
// asynchronously, there is a very real chance that the provider might
// have cancelled the channel after _this_ event was triggered.
// have cancelled the request after _this_ event was triggered.
//
if (NS_SUCCEEDED(status)) {
LOG(("nsOnDataWritableEvent: Calling the consumer's OnDataWritable\n"));
rv = provider->OnDataWritable(mChannel, mContext, mSink, mOffset, mCount);
rv = provider->OnDataWritable(mRequest, mContext, mSink, mOffset, mCount);
LOG(("nsOnDataWritableEvent: Done with the consumer's OnDataWritable [rv=%x]\n", rv));
//
@@ -122,11 +122,11 @@ nsOnDataWritableEvent::HandleEvent()
rv != NS_BASE_STREAM_WOULD_BLOCK ? rv : NS_OK);
//
// The channel is already suspended, so unless the provider returned
// NS_BASE_STREAM_WOULD_BLOCK, we should wake up the channel.
// The request is already suspended, so unless the provider returned
// NS_BASE_STREAM_WOULD_BLOCK, we should wake up the request.
//
if (rv != NS_BASE_STREAM_WOULD_BLOCK)
mChannel->Resume();
mRequest->Resume();
}
else
LOG(("nsOnDataWritableEvent: Not calling OnDataWritable"));
@@ -149,14 +149,14 @@ NS_IMPL_ISUPPORTS_INHERITED2(nsStreamProviderProxy,
//----------------------------------------------------------------------------
//
NS_IMETHODIMP
nsStreamProviderProxy::OnStartRequest(nsIChannel *aChannel,
nsStreamProviderProxy::OnStartRequest(nsIRequest *request,
nsISupports *aContext)
{
return nsStreamProxyBase::OnStartRequest(aChannel, aContext);
return nsStreamProxyBase::OnStartRequest(request, aContext);
}
NS_IMETHODIMP
nsStreamProviderProxy::OnStopRequest(nsIChannel *aChannel,
nsStreamProviderProxy::OnStopRequest(nsIRequest* request,
nsISupports *aContext,
nsresult aStatus,
const PRUnichar *aStatusText)
@@ -167,7 +167,7 @@ nsStreamProviderProxy::OnStopRequest(nsIChannel *aChannel,
mPipeIn = 0;
mPipeOut = 0;
return nsStreamProxyBase::OnStopRequest(aChannel, aContext,
return nsStreamProxyBase::OnStopRequest(request, aContext,
aStatus, aStatusText);
}
@@ -189,7 +189,7 @@ nsWriteToSink(nsIInputStream *source,
}
NS_IMETHODIMP
nsStreamProviderProxy::OnDataWritable(nsIChannel *aChannel,
nsStreamProviderProxy::OnDataWritable(nsIRequest *aRequest,
nsISupports *aContext,
nsIOutputStream *aSink,
PRUint32 aOffset,
@@ -215,7 +215,7 @@ nsStreamProviderProxy::OnDataWritable(nsIChannel *aChannel,
}
//
// Provide the channel with whatever data is already in the pipe (not
// Provide the request with whatever data is already in the pipe (not
// exceeding aCount).
//
PRUint32 count;
@@ -236,7 +236,7 @@ nsStreamProviderProxy::OnDataWritable(nsIChannel *aChannel,
// Post an event requesting the provider for more data.
//
nsOnDataWritableEvent *ev =
new nsOnDataWritableEvent(this, aChannel, aContext,
new nsOnDataWritableEvent(this, aRequest, aContext,
mPipeOut, aOffset, aCount);
if (!ev)
return NS_ERROR_OUT_OF_MEMORY;

6
netwerk/base/src/nsSyncStreamListener.cpp
View File

@@ -55,13 +55,13 @@ NS_IMPL_THREADSAFE_ISUPPORTS3(nsSyncStreamListener,
nsIStreamObserver)
NS_IMETHODIMP
nsSyncStreamListener::OnStartRequest(nsIChannel* channel, nsISupports* context)
nsSyncStreamListener::OnStartRequest(nsIRequest* request, nsISupports* context)
{
return NS_OK;
}
NS_IMETHODIMP
nsSyncStreamListener::OnStopRequest(nsIChannel* channel, nsISupports* context,
nsSyncStreamListener::OnStopRequest(nsIRequest* request, nsISupports* context,
nsresult aStatus, const PRUnichar* aStatusArg)
{
// XXX what do we do with the status and error message?
@@ -69,7 +69,7 @@ nsSyncStreamListener::OnStopRequest(nsIChannel* channel, nsISupports* context,
}
NS_IMETHODIMP
nsSyncStreamListener::OnDataAvailable(nsIChannel* channel,
nsSyncStreamListener::OnDataAvailable(nsIRequest* request,
nsISupports* context,
nsIInputStream *aIStream,
PRUint32 aSourceOffset,

24
netwerk/cache/filecache/nsDiskCacheRecord.cpp vendored
View File

@@ -68,7 +68,7 @@ nsDiskCacheRecord::nsDiskCacheRecord(nsIDBAccessor* db, nsNetDiskCache* aCache)
mDB(db) ,
mInfo(0) ,
mInfoSize(0) ,
mNumChannels(0) ,
mNumTransports(0) ,
mDiskCache(aCache)
{
NS_INIT_REFCNT();
@@ -284,7 +284,7 @@ nsDiskCacheRecord::SetSecurityInfo (nsISupports * o_SecurityInfo)
NS_IMETHODIMP
nsDiskCacheRecord::Delete(void)
{
if(mNumChannels)
if(mNumTransports)
return NS_ERROR_NOT_AVAILABLE ;
// Delete any file associated with this entry. Remember we might
@@ -333,19 +333,20 @@ nsDiskCacheRecord::GetFile(nsIFile * *aFile)
}
NS_IMETHODIMP
nsDiskCacheRecord::NewChannel(nsILoadGroup *loadGroup, nsIChannel **_retval)
nsDiskCacheRecord::NewTransport(nsILoadGroup *loadGroup, nsITransport **_retval)
{
nsDiskCacheRecordChannel* channel = new nsDiskCacheRecordChannel(this, loadGroup) ;
if(!channel)
return NS_ERROR_OUT_OF_MEMORY ;
nsDiskCacheRecordTransport* transport =
new nsDiskCacheRecordTransport(this, loadGroup);
if(!transport)
return NS_ERROR_OUT_OF_MEMORY;
nsresult rv = channel->Init() ;
nsresult rv = transport->Init();
if(NS_FAILED(rv))
return rv ;
return rv;
NS_ADDREF(channel) ;
*_retval = NS_STATIC_CAST(nsIChannel*, channel) ;
return NS_OK ;
NS_ADDREF(transport);
*_retval = NS_STATIC_CAST(nsITransport*, transport);
return NS_OK;
}
//////////////////////////////////////////////////////////////////////////
@@ -561,3 +562,4 @@ nsDiskCacheRecord::UpdateFileInfo()
mFile = spec;
return rv;
}

47
netwerk/cache/filecache/nsDiskCacheRecord.h vendored
View File

@@ -34,8 +34,7 @@
class nsDiskCacheRecord : public nsINetDataCacheRecord
{
public:
public:
NS_DECL_ISUPPORTS
NS_DECL_NSINETDATACACHERECORD
@@ -46,15 +45,15 @@ class nsDiskCacheRecord : public nsINetDataCacheRecord
// we need to invalidate the mFile's stat cache.
NS_IMETHOD WriteComplete();
protected:
protected:
nsDiskCacheRecord(nsIDBAccessor* db, nsNetDiskCache* aCache) ;
virtual ~nsDiskCacheRecord() ;
nsDiskCacheRecord(nsIDBAccessor* db, nsNetDiskCache* aCache);
virtual ~nsDiskCacheRecord();
NS_IMETHOD RetrieveInfo(void* aInfo, PRUint32 aInfoLength) ;
NS_IMETHOD Init(const char* key, PRUint32 length, PRInt32 ID) ;
NS_IMETHOD RetrieveInfo(void* aInfo, PRUint32 aInfoLength);
NS_IMETHOD Init(const char* key, PRUint32 length, PRInt32 ID);
nsresult GenInfo(void) ;
nsresult GenInfo(void);
// The mFile we store might be out of date. Atlease
@@ -64,23 +63,23 @@ class nsDiskCacheRecord : public nsINetDataCacheRecord
// file info.
NS_IMETHOD UpdateFileInfo();
private:
private:
char* mKey ;
PRUint32 mKeyLength ;
PRInt32 mRecordID ;
char* mMetaData ;
PRUint32 mMetaDataLength ;
nsCOMPtr<nsIFile> mFile ;
nsCOMPtr<nsIDBAccessor> mDB ;
void* mInfo ;
PRUint32 mInfoSize ;
PRUint32 mNumChannels ;
nsNetDiskCache* mDiskCache ;
char* mKey;
PRUint32 mKeyLength;
PRInt32 mRecordID;
char* mMetaData;
PRUint32 mMetaDataLength;
nsCOMPtr<nsIFile> mFile;
nsCOMPtr<nsIDBAccessor> mDB;
void* mInfo;
PRUint32 mInfoSize;
PRUint32 mNumTransports;
nsNetDiskCache* mDiskCache;
friend class nsDiskCacheRecordChannel ;
friend class nsDBEnumerator ;
friend class nsNetDiskCache ;
} ;
friend class nsDiskCacheRecordTransport;
friend class nsDBEnumerator;
friend class nsNetDiskCache;
};
#endif // _NET_CACHEDDISKDATA_H_

465
netwerk/cache/filecache/nsDiskCacheRecordChannel.cpp vendored
View File

@@ -45,19 +45,19 @@ static NS_DEFINE_CID(kStandardURLCID, NS_STANDARDURL_CID);
class WriteStreamWrapper : public nsIOutputStream
{
public:
WriteStreamWrapper(nsDiskCacheRecordChannel* aChannel,
WriteStreamWrapper(nsDiskCacheRecordTransport* aTransport,
nsIOutputStream *aBaseStream);
virtual ~WriteStreamWrapper();
static nsresult
Create(nsDiskCacheRecordChannel* aChannel, nsIOutputStream *aBaseStream, nsIOutputStream* *aWrapper);
Create(nsDiskCacheRecordTransport* aTransport, nsIOutputStream *aBaseStream, nsIOutputStream* *aWrapper);
NS_DECL_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAM
private:
nsDiskCacheRecordChannel* mChannel;
nsDiskCacheRecordTransport* mTransport;
nsCOMPtr<nsIOutputStream> mBaseStream;
PRUint32 mTotalSize;
PRUint32 mOldLength;
@@ -66,24 +66,24 @@ class WriteStreamWrapper : public nsIOutputStream
// implement nsISupports
NS_IMPL_THREADSAFE_ISUPPORTS1(WriteStreamWrapper, nsIOutputStream)
WriteStreamWrapper::WriteStreamWrapper(nsDiskCacheRecordChannel* aChannel,
WriteStreamWrapper::WriteStreamWrapper(nsDiskCacheRecordTransport* aTransport,
nsIOutputStream *aBaseStream)
: mChannel(aChannel), mBaseStream(aBaseStream), mTotalSize(0), mOldLength(0)
: mTransport(aTransport), mBaseStream(aBaseStream), mTotalSize(0), mOldLength(0)
{
NS_INIT_REFCNT();
NS_ADDREF(mChannel);
mChannel->mRecord->GetStoredContentLength(&mOldLength);
NS_ADDREF(mTransport);
mTransport->mRecord->GetStoredContentLength(&mOldLength);
}
WriteStreamWrapper::~WriteStreamWrapper()
{
NS_RELEASE(mChannel);
NS_RELEASE(mTransport);
}
nsresult
WriteStreamWrapper::Create(nsDiskCacheRecordChannel*aChannel, nsIOutputStream *aBaseStream, nsIOutputStream* * aWrapper)
WriteStreamWrapper::Create(nsDiskCacheRecordTransport*aTransport, nsIOutputStream *aBaseStream, nsIOutputStream* * aWrapper)
{
WriteStreamWrapper *wrapper = new WriteStreamWrapper(aChannel, aBaseStream);
WriteStreamWrapper *wrapper = new WriteStreamWrapper(aTransport, aBaseStream);
if (!wrapper) return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(wrapper);
*aWrapper = wrapper;
@@ -153,36 +153,35 @@ WriteStreamWrapper::Close()
nsresult rv = mBaseStream->Close();
// Tell the record we finished write to the file
mChannel->mRecord->WriteComplete();
mTransport->mRecord->WriteComplete();
if (mTotalSize < mOldLength) {
// Truncate the file if we have to. It should have been already but that
// would be too easy wouldn't it!!!
mChannel->mRecord->SetStoredContentLength(mTotalSize);
mTransport->mRecord->SetStoredContentLength(mTotalSize);
} else if (mTotalSize > mOldLength) {
mChannel->NotifyStorageInUse(mTotalSize - mOldLength);
mTransport->NotifyStorageInUse(mTotalSize - mOldLength);
}
return rv;
}
nsDiskCacheRecordChannel::nsDiskCacheRecordChannel(nsDiskCacheRecord *aRecord,
nsDiskCacheRecordTransport::nsDiskCacheRecordTransport(nsDiskCacheRecord *aRecord,
nsILoadGroup *aLoadGroup)
: mRecord(aRecord),
mLoadGroup(aLoadGroup),
mLoadAttributes(nsIChannel::LOAD_NORMAL),
mStatus(NS_OK)
{
NS_INIT_REFCNT();
NS_ADDREF(mRecord);
mRecord->mNumChannels++;
mRecord->mNumTransports++;
}
nsDiskCacheRecordChannel::~nsDiskCacheRecordChannel()
nsDiskCacheRecordTransport::~nsDiskCacheRecordTransport()
{
mRecord->mNumChannels--;
mRecord->mNumTransports--;
NS_RELEASE(mRecord);
}
@@ -205,7 +204,7 @@ nsDiskCacheRecordChannel::~nsDiskCacheRecordChannel()
// conversions for every cache file we open.
nsresult
nsDiskCacheRecordChannel::Init(void)
nsDiskCacheRecordTransport::Init(void)
{
nsresult rv = mRecord->mFile->Clone(getter_AddRefs(mSpec)) ;
#if 0
@@ -226,110 +225,125 @@ nsDiskCacheRecordChannel::Init(void)
}
nsresult
nsDiskCacheRecordChannel::NotifyStorageInUse(PRInt32 aBytesUsed)
nsDiskCacheRecordTransport::NotifyStorageInUse(PRInt32 aBytesUsed)
{
return mRecord->mDiskCache->mStorageInUse += aBytesUsed;
}
// implement nsISupports
NS_IMPL_THREADSAFE_ISUPPORTS4(nsDiskCacheRecordChannel,
nsIChannel,
NS_IMPL_THREADSAFE_ISUPPORTS5(nsDiskCacheRecordTransport,
nsITransport,
nsITransportRequest,
nsIRequest,
nsIStreamListener,
nsIStreamObserver)
// implement nsIRequest
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetName(PRUnichar* *result)
nsDiskCacheRecordTransport::GetName(PRUnichar* *result)
{
NS_NOTREACHED("nsDiskCacheRecordChannel::GetName");
NS_NOTREACHED("nsDiskCacheRecordTransport::GetName");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::IsPending(PRBool *aIsPending)
nsDiskCacheRecordTransport::IsPending(PRBool *aIsPending)
{
*aIsPending = PR_FALSE;
if(!mFileTransport)
if(!mCurrentReadRequest)
return NS_OK;
return mFileTransport->IsPending(aIsPending);
return mCurrentReadRequest->IsPending(aIsPending);
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetStatus(nsresult *status)
nsDiskCacheRecordTransport::GetStatus(nsresult *status)
{
*status = mStatus;
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::Cancel(nsresult status)
nsDiskCacheRecordTransport::Cancel(nsresult status)
{
NS_ASSERTION(NS_FAILED(status), "shouldn't cancel with a success code");
mStatus = status;
if(!mFileTransport)
if(!mCurrentReadRequest)
return NS_ERROR_FAILURE;
return mFileTransport->Cancel(status);
return mCurrentReadRequest->Cancel(status);
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::Suspend(void)
nsDiskCacheRecordTransport::Suspend(void)
{
if(!mFileTransport)
if(!mCurrentReadRequest)
return NS_ERROR_FAILURE;
return mFileTransport->Suspend();
return mCurrentReadRequest->Suspend();
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::Resume(void)
nsDiskCacheRecordTransport::Resume(void)
{
if(!mFileTransport)
if(!mCurrentReadRequest)
return NS_ERROR_FAILURE;
return mFileTransport->Resume();
return mCurrentReadRequest->Resume();
}
NS_IMETHODIMP
nsDiskCacheRecordTransport::GetTransport(nsITransport **result)
{
NS_ENSURE_ARG_POINTER(result);
NS_ADDREF(*result = this);
return NS_OK;
}
#if 0
// implement nsIChannel
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetOriginalURI(nsIURI* *aURI)
nsDiskCacheRecordTransport::GetOriginalURI(nsIURI* *aURI)
{
// FUR - might need to implement this - not sure
NS_NOTREACHED("nsDiskCacheRecordChannel::GetOriginalURI");
NS_NOTREACHED("nsDiskCacheRecordTransport::GetOriginalURI");
return NS_ERROR_NOT_IMPLEMENTED ;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::SetOriginalURI(nsIURI* aURI)
nsDiskCacheRecordTransport::SetOriginalURI(nsIURI* aURI)
{
// FUR - might need to implement this - not sure
NS_NOTREACHED("nsDiskCacheRecordChannel::SetOriginalURI");
NS_NOTREACHED("nsDiskCacheRecordTransport::SetOriginalURI");
return NS_ERROR_NOT_IMPLEMENTED ;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetURI(nsIURI* *aURI)
nsDiskCacheRecordTransport::GetURI(nsIURI* *aURI)
{
if(!mFileTransport)
return NS_ERROR_FAILURE;
return mFileTransport->GetURI(aURI);
return mFileTransport->GetURI(aURI); // no-op
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::SetURI(nsIURI* aURI)
nsDiskCacheRecordTransport::SetURI(nsIURI* aURI)
{
if(!mFileTransport)
return NS_ERROR_FAILURE;
return mFileTransport->SetURI(aURI);
return mFileTransport->SetURI(aURI); // no-op
}
#endif
NS_IMETHODIMP
nsDiskCacheRecordChannel::OpenInputStream(nsIInputStream* *aResult)
nsDiskCacheRecordTransport::OpenInputStream(PRUint32 transferOffset,
PRUint32 transferCount,
PRUint32 transferFlags,
nsIInputStream* *aResult)
{
nsresult rv;
@@ -339,14 +353,19 @@ nsDiskCacheRecordChannel::OpenInputStream(nsIInputStream* *aResult)
NS_WITH_SERVICE(nsIFileTransportService, fts, kFileTransportServiceCID, &rv);
if(NS_FAILED(rv)) return rv;
rv = fts->CreateTransport(mSpec, PR_RDONLY, PR_IRUSR | PR_IWUSR,
rv = fts->CreateTransport(mSpec,
PR_RDONLY,
PR_IRUSR | PR_IWUSR,
getter_AddRefs(mFileTransport));
if(NS_FAILED(rv))
return rv;
// we don't need to worry about notification callbacks
// we don't need to worry about progress notification
rv = mFileTransport->OpenInputStream(aResult);
rv = mFileTransport->OpenInputStream(transferOffset,
transferCount,
transferFlags,
aResult);
if(NS_FAILED(rv))
mFileTransport = nsnull;
@@ -354,7 +373,10 @@ nsDiskCacheRecordChannel::OpenInputStream(nsIInputStream* *aResult)
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::OpenOutputStream(nsIOutputStream* *aResult)
nsDiskCacheRecordTransport::OpenOutputStream(PRUint32 transferOffset,
PRUint32 transferCount,
PRUint32 transferFlags,
nsIOutputStream* *aResult)
{
nsresult rv;
NS_ENSURE_ARG(aResult);
@@ -367,14 +389,19 @@ nsDiskCacheRecordChannel::OpenOutputStream(nsIOutputStream* *aResult)
NS_WITH_SERVICE(nsIFileTransportService, fts, kFileTransportServiceCID, &rv);
if(NS_FAILED(rv)) return rv;
rv = fts->CreateTransport(mSpec, PR_WRONLY | PR_CREATE_FILE, PR_IRUSR | PR_IWUSR,
rv = fts->CreateTransport(mSpec,
PR_WRONLY | PR_CREATE_FILE,
PR_IRUSR | PR_IWUSR,
getter_AddRefs(mFileTransport));
if(NS_FAILED(rv))
return rv;
// we don't need to worry about notification callbacks
rv = mFileTransport->OpenOutputStream(getter_AddRefs(outputStream));
rv = mFileTransport->OpenOutputStream(transferOffset,
transferCount,
transferFlags,
getter_AddRefs(outputStream));
if(NS_FAILED(rv)) {
mFileTransport = nsnull;
return rv;
@@ -384,8 +411,12 @@ nsDiskCacheRecordChannel::OpenOutputStream(nsIOutputStream* *aResult)
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::AsyncRead(nsIStreamListener *aListener,
nsISupports *aContext)
nsDiskCacheRecordTransport::AsyncRead(nsIStreamListener *aListener,
nsISupports *aContext,
PRUint32 transferOffset,
PRUint32 transferCount,
PRUint32 transferFlags,
nsIRequest **_retval)
{
nsresult rv;
@@ -395,6 +426,8 @@ nsDiskCacheRecordChannel::AsyncRead(nsIStreamListener *aListener,
mRealListener = aListener;
nsCOMPtr<nsIStreamListener> tempListener = this;
// XXX Only channels are added to load groups
#if 0
if (mLoadGroup) {
nsCOMPtr<nsILoadGroupListenerFactory> factory;
//
@@ -410,33 +443,45 @@ nsDiskCacheRecordChannel::AsyncRead(nsIStreamListener *aListener,
}
}
rv = mLoadGroup->AddChannel(this, nsnull);
rv = mLoadGroup->AddRequest(this, nsnull);
if (NS_FAILED(rv)) return rv;
}
#endif
NS_WITH_SERVICE(nsIFileTransportService, fts, kFileTransportServiceCID, &rv);
if (NS_FAILED(rv)) return rv;
rv = fts->CreateTransport(mSpec, PR_RDONLY, PR_IRUSR | PR_IWUSR,
rv = fts->CreateTransport(mSpec,
PR_RDONLY,
PR_IRUSR | PR_IWUSR,
getter_AddRefs(mFileTransport));
if (NS_FAILED(rv)) return rv;
// no callbacks
rv = mFileTransport->AsyncRead(tempListener, aContext);
rv = mFileTransport->AsyncRead(tempListener, aContext,
transferOffset,
transferCount,
transferFlags,
getter_AddRefs(mCurrentReadRequest));
if (NS_FAILED(rv)) {
// release the transport so that we don't think we're in progress
mFileTransport = nsnull;
}
NS_ADDREF(*_retval=this);
return rv;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::AsyncWrite(nsIStreamProvider *provider,
nsISupports *ctxt)
nsDiskCacheRecordTransport::AsyncWrite(nsIStreamProvider *provider,
nsISupports *ctxt,
PRUint32 transferOffset,
PRUint32 transferCount,
PRUint32 transferFlags,
nsIRequest **_retval)
{
/*
if(!mFileTransport)
@@ -451,279 +496,66 @@ nsDiskCacheRecordChannel::AsyncWrite(nsIStreamProvider *provider,
// I can't do this since the write is not monitored, and I won't be
// able to updata the storage.
NS_NOTREACHED("nsDiskCacheRecordChannel::AsyncWrite");
NS_NOTREACHED("nsDiskCacheRecordTransport::AsyncWrite");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetLoadAttributes(nsLoadFlags *aLoadAttributes)
{
*aLoadAttributes = mLoadAttributes;
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::SetLoadAttributes(nsLoadFlags aLoadAttributes)
{
mLoadAttributes = aLoadAttributes;
return NS_OK;
}
#define DUMMY_TYPE "application/x-unknown-content-type"
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetContentType(char * *aContentType)
{
// Not required to be implemented, since it is implemented by cache manager
NS_NOTREACHED("nsDiskCacheRecordChannel::GetContentType");
return NS_ERROR_NOT_IMPLEMENTED;
// This was the pre nsIFile stuff. Not sure if I have to implement this routines since
// the memory cache doesn't
#if 0
nsresult rv;
PRBool isDirectory;
if ( NS_SUCCEEDED(mSpec->IsDirectory(&isDirectory)) && isDirectory) {
*aContentType = nsCRT::strdup("application/http-index-format");
return *aContentType ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
else {
// I wish I can make this simplier
char* urlStr;
mRecord->mFile->GetURLString(&urlStr);
// file: URLs (currently) have no additional structure beyond that provided by standard
// URLs, so there is no "outer" given to CreateInstance
nsCOMPtr<nsIURI> url;
rv = nsComponentManager::CreateInstance(kStandardURLCID, nsnull,
NS_GET_IID(nsIURI),
//(void**)&url);
getter_AddRefs(url));
if (NS_FAILED(rv)) return rv;
rv = url->SetSpec((char*)urlStr);
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIMIMEService> MIMEService (do_GetService(NS_MIMESERVICE_CONTRACTID, &rv));
if (NS_FAILED(rv)) return rv;
rv = MIMEService->GetTypeFromURI(url, aContentType);
if (NS_SUCCEEDED(rv)) return rv;
}
*aContentType = nsCRT::strdup(DUMMY_TYPE);
if (!*aContentType) {
return NS_ERROR_OUT_OF_MEMORY;
} else {
return NS_OK;
}
#endif
}
NS_IMETHODIMP nsDiskCacheRecordChannel::SetContentType(const char * aContentType)
{
NS_NOTREACHED("nsDiskCacheRecordChannel::SetContentType");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetContentLength(PRInt32 *aContentLength)
{
nsresult rv;
PRUint32 length;
PRInt64 fileSize;
rv = mRecord->mFile->GetFileSize( &fileSize);
LL_L2UI( length, fileSize );
if (NS_SUCCEEDED(rv)) {
*aContentLength = (PRInt32)length;
} else {
*aContentLength = -1;
}
return rv;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::SetContentLength(PRInt32 aContentLength)
{
NS_NOTREACHED("nsDiskCacheRecordChannel::SetContentLength");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetTransferOffset(PRUint32 *aTransferOffset)
{
nsresult rv = NS_ERROR_FAILURE;
if ( mFileTransport )
rv = mFileTransport->GetTransferOffset( aTransferOffset );
return rv;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::SetTransferOffset(PRUint32 aTransferOffset)
{
nsresult rv = NS_OK;
if ( mFileTransport )
rv = mFileTransport->SetTransferOffset( aTransferOffset );
return rv;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetTransferCount(PRInt32 *aTransferCount)
{
NS_NOTREACHED("nsDiskCacheRecordChannel::GetTransferCount");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::SetTransferCount(PRInt32 aTransferCount)
{
NS_NOTREACHED("nsDiskCacheRecordChannel::SetTransferCount");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetBufferSegmentSize(PRUint32 *aBufferSegmentSize)
{
NS_NOTREACHED("nsDiskCacheRecordChannel::GetBufferSegmentSize");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::SetBufferSegmentSize(PRUint32 aBufferSegmentSize)
{
NS_NOTREACHED("nsDiskCacheRecordChannel::SetBufferSegmentSize");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetBufferMaxSize(PRUint32 *aBufferMaxSize)
{
NS_NOTREACHED("nsDiskCacheRecordChannel::GetBufferMaxSize");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::SetBufferMaxSize(PRUint32 aBufferMaxSize)
{
NS_NOTREACHED("nsDiskCacheRecordChannel::SetBufferMaxSize");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetLocalFile(nsIFile* *file)
{
*file = mSpec;
NS_ADDREF(*file);
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetPipeliningAllowed(PRBool *aPipeliningAllowed)
{
*aPipeliningAllowed = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::SetPipeliningAllowed(PRBool aPipeliningAllowed)
{
NS_NOTREACHED("SetPipeliningAllowed");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetOwner(nsISupports* *aOwner)
{
*aOwner = mOwner.get();
NS_IF_ADDREF(*aOwner);
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::SetOwner(nsISupports* aOwner)
{
mOwner = aOwner;
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
{
// Not required to be implemented, since it is implemented by cache manager
NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::SetLoadGroup(nsILoadGroup* aLoadGroup)
{
// Not required to be implemented, since it is implemented by cache manager
NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetNotificationCallbacks(nsIInterfaceRequestor* *aNotificationCallbacks)
{
// Not required to be implemented, since it is implemented by cache manager
NS_NOTREACHED("nsDiskCacheRecordChannel::GetNotificationCallbacks");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aNotificationCallbacks)
{
// Not required to be implemented, since it is implemented by cache manager
NS_NOTREACHED("nsDiskCacheRecordChannel::SetNotificationCallbacks");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::GetSecurityInfo(nsISupports * *aSecurityInfo)
nsDiskCacheRecordTransport::GetSecurityInfo(nsISupports * *aSecurityInfo)
{
*aSecurityInfo = nsnull;
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheRecordTransport::GetProgressEventSink(nsIProgressEventSink **aResult)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDiskCacheRecordTransport::SetProgressEventSink(nsIProgressEventSink *aProgress)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
////////////////////////////////////////////////////////////////////////////////
// nsIStreamListener methods:
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsDiskCacheRecordChannel::OnStartRequest(nsIChannel* transportChannel, nsISupports* context)
nsDiskCacheRecordTransport::OnStartRequest(nsIRequest *request, nsISupports* context)
{
NS_ASSERTION(mRealListener, "No listener...");
return mRealListener->OnStartRequest(this, context);
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::OnStopRequest(nsIChannel* transportChannel, nsISupports* context,
nsDiskCacheRecordTransport::OnStopRequest(nsIRequest *request, nsISupports* context,
nsresult aStatus, const PRUnichar* aStatusArg)
{
nsresult rv;
rv = mRealListener->OnStopRequest(this, context, aStatus, aStatusArg);
// XXX Only channels are added to load groups
#if 0
if (mLoadGroup) {
if (NS_SUCCEEDED(rv)) {
mLoadGroup->RemoveChannel(this, context, aStatus, aStatusArg);
mLoadGroup->RemoveRequest(this, context, aStatus, aStatusArg);
}
}
#endif
// Release the reference to the consumer stream listener...
mRealListener = null_nsCOMPtr();
mFileTransport = null_nsCOMPtr();
mRealListener = 0;
mFileTransport = 0;
mCurrentReadRequest = 0;
return rv;
}
NS_IMETHODIMP
nsDiskCacheRecordChannel::OnDataAvailable(nsIChannel* transportChannel, nsISupports* context,
nsDiskCacheRecordTransport::OnDataAvailable(nsIRequest *request, nsISupports* context,
nsIInputStream *aIStream, PRUint32 aSourceOffset,
PRUint32 aLength)
{
@@ -737,9 +569,44 @@ nsDiskCacheRecordChannel::OnDataAvailable(nsIChannel* transportChannel, nsISuppo
// insure that the transport will go away even if it is blocked waiting
// for the consumer to empty the pipe...
//
if (NS_FAILED(rv) && mFileTransport) {
mFileTransport->Cancel(rv);
if (NS_FAILED(rv) && mCurrentReadRequest) {
mCurrentReadRequest->Cancel(rv);
}
return rv;
}
// XXX No reason to implement nsIFileChannel
#if 0
/* void init (in nsIFile file, in long ioFlags, in long perm); */
NS_IMETHODIMP nsDiskCacheRecordTransport::Init(nsIFile *file, PRInt32 ioFlags, PRInt32 perm)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* readonly attribute nsIFile file; */
NS_IMETHODIMP nsDiskCacheRecordTransport::GetFile(nsIFile * *result)
{
NS_ADDREF(*result = mSpec);
return NS_OK;
}
/* attribute long ioFlags; */
NS_IMETHODIMP nsDiskCacheRecordTransport::GetIoFlags(PRInt32 *aIoFlags)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDiskCacheRecordTransport::SetIoFlags(PRInt32 aIoFlags)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* attribute long permissions; */
NS_IMETHODIMP nsDiskCacheRecordTransport::GetPermissions(PRInt32 *aPermissions)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDiskCacheRecordTransport::SetPermissions(PRInt32 aPermissions)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
#endif

Some files were not shown because too many files have changed in this diff Show More