mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

modifications for bug 176919 "async streams" r=dougt,gordon sr=sspitzer a=valeski,asa

This commit is contained in:
darin%netscape.com 2003-01-18 02:15:14 +00:00
Родитель 0b4f800fbf
Коммит 685a7af468
172 изменённых файлов: 7238 добавлений и 9820 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
content/html/document/public/nsIWyciwygChannel.idl
Просмотреть файл

@ -56,5 +56,5 @@ interface nsIWyciwygChannel : nsIChannel
/**
* Close the cache entry; subsequent writes have undefined behavior.
*/
void closeCacheEntry();
void closeCacheEntry(in nsresult reason);
};

2
content/html/document/src/nsHTMLDocument.cpp
Просмотреть файл

@ -4029,7 +4029,7 @@ nsHTMLDocument::RemoveWyciwygChannel(void)
// note there can be a write request without a load group if
// this is a synchronously constructed about:blank document
if (loadGroup && mWyciwygChannel) {
mWyciwygChannel->CloseCacheEntry();
mWyciwygChannel->CloseCacheEntry(NS_OK);
rv = loadGroup->RemoveRequest(mWyciwygChannel, nsnull, NS_OK);
if (NS_FAILED(rv)) return rv;
}

374
content/html/document/src/nsWyciwygChannel.cpp
Просмотреть файл

@ -32,12 +32,14 @@
PRLogModuleInfo * gWyciwygLog = nsnull;
#define wyciwyg_TYPE "text/html"
#define LOG(args) PR_LOG(gWyciwygLog, 4, args)
// nsWyciwygChannel methods
nsWyciwygChannel::nsWyciwygChannel()
: mStatus(NS_OK),
mLoadFlags(LOAD_NORMAL),
mIsPending(PR_FALSE)
: mContentLength(-1)
, mLoadFlags(LOAD_NORMAL)
, mStatus(NS_OK)
, mIsPending(PR_FALSE)
{
}
@ -45,47 +47,22 @@ nsWyciwygChannel::~nsWyciwygChannel()
{
}
NS_IMPL_THREADSAFE_ISUPPORTS8(nsWyciwygChannel, nsIChannel, nsIRequest,
nsIStreamListener, nsICacheListener,
nsIInterfaceRequestor, nsIWyciwygChannel,
nsIRequestObserver, nsIProgressEventSink)
NS_IMPL_ISUPPORTS6(nsWyciwygChannel,
nsIChannel,
nsIRequest,
nsIStreamListener,
nsIRequestObserver,
nsICacheListener,
nsIWyciwygChannel)
nsresult
nsWyciwygChannel::Init(nsIURI* uri)
{
if (!uri)
return NS_ERROR_NULL_POINTER;
NS_ENSURE_ARG_POINTER(uri);
mURI = uri;
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsHttpChannel::nsIInterfaceRequestor
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsWyciwygChannel::GetInterface(const nsIID &aIID, void **aResult)
{
if (aIID.Equals(NS_GET_IID(nsIProgressEventSink))) {
//
// we return ourselves as the progress event sink so we can intercept
// notifications and set the correct request and context parameters.
// but, if we don't have a progress sink to forward those messages
// to, then there's no point in handing out a reference to ourselves.
//
if (!mProgressSink)
return NS_ERROR_NO_INTERFACE;
return QueryInterface(aIID, aResult);
}
if (mCallbacks)
return mCallbacks->GetInterface(aIID, aResult);
return NS_ERROR_NO_INTERFACE;
}
///////////////////////////////////////////////////////////////////////////////
// nsIRequest methods:
///////////////////////////////////////////////////////////////////////////////
@ -106,39 +83,38 @@ nsWyciwygChannel::IsPending(PRBool *aIsPending)
NS_IMETHODIMP
nsWyciwygChannel::GetStatus(nsresult *aStatus)
{
*aStatus = mStatus;
if (NS_SUCCEEDED(mStatus) && mPump)
mPump->GetStatus(aStatus);
else
*aStatus = mStatus;
return NS_OK;
}
NS_IMETHODIMP
nsWyciwygChannel::Cancel(nsresult aStatus)
nsWyciwygChannel::Cancel(nsresult status)
{
LOG(("nsWyciwygChannel::Cancel [this=%x status=%x]\n", this, aStatus));
NS_ASSERTION(NS_FAILED(aStatus), "shouldn't cancel with a success code");
mStatus = aStatus;
if (mCacheReadRequest)
mCacheReadRequest->Cancel(aStatus);
// Clear out all cache handles.
CloseCacheEntry();
mStatus = status;
if (mPump)
mPump->Cancel(status);
// else we're waiting for OnCacheEntryAvailable
return NS_OK;
}
NS_IMETHODIMP
nsWyciwygChannel::Suspend(void)
nsWyciwygChannel::Suspend()
{
LOG(("nsWyciwygChannel::Suspend [this=%x]\n", this));
if (mCacheReadRequest)
return mCacheReadRequest->Suspend();
if (mPump)
mPump->Suspend();
// XXX else, we'll ignore this ... and that's probably bad!
return NS_OK;
}
NS_IMETHODIMP
nsWyciwygChannel::Resume(void)
nsWyciwygChannel::Resume()
{
LOG(("nsWyciwygChannel::Resume [this=%x]\n", this));
if (mCacheReadRequest)
return mCacheReadRequest->Resume();
if (mPump)
mPump->Resume();
// XXX else, we'll ignore this ... and that's probably bad!
return NS_OK;
}
@ -176,6 +152,7 @@ nsWyciwygChannel::GetLoadFlags(PRUint32 * aLoadFlags)
////////////////////////////////////////////////////////////////////////////////
// nsIChannel methods:
///////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsWyciwygChannel::GetOriginalURI(nsIURI* *aURI)
{
@ -205,36 +182,24 @@ nsWyciwygChannel::GetURI(nsIURI* *aURI)
}
NS_IMETHODIMP
nsWyciwygChannel::GetOwner(nsISupports* *aOwner)
nsWyciwygChannel::GetOwner(nsISupports **aOwner)
{
nsresult rv = NS_OK;
if (!mOwner) {
// Create codebase principal with URI of original document, not our URI
NS_ASSERTION(mOriginalURI,
"nsWyciwygChannel::GetOwner without an owner or an original URI!");
if (mOriginalURI) {
nsIPrincipal* pIPrincipal = nsnull;
nsCOMPtr<nsIScriptSecurityManager> secMan(do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv));
if (secMan) {
rv = secMan->GetCodebasePrincipal(mOriginalURI, &pIPrincipal);
if (NS_SUCCEEDED(rv)) {
mOwner = pIPrincipal;
NS_RELEASE(pIPrincipal);
}
}
} else {
// Uh oh, must set originalURI before we can return an owner!
return NS_ERROR_FAILURE;
NS_ENSURE_TRUE(mOriginalURI, NS_ERROR_FAILURE); // without an owner or an original URI!
nsCOMPtr<nsIPrincipal> principal;
nsCOMPtr<nsIScriptSecurityManager> secMan(do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv));
if (secMan) {
rv = secMan->GetCodebasePrincipal(mOriginalURI, getter_AddRefs(principal));
if (NS_SUCCEEDED(rv))
mOwner = principal;
}
}
NS_ASSERTION(mOriginalURI,
"nsWyciwygChannel::GetOwner unable to get owner!");
if (mOwner) {
*aOwner = mOwner.get();
NS_IF_ADDREF(*aOwner);
} else {
*aOwner = nsnull;
}
NS_IF_ADDREF(*aOwner = mOwner);
return rv;
}
@ -312,30 +277,39 @@ nsWyciwygChannel::Open(nsIInputStream ** aReturn)
}
NS_IMETHODIMP
nsWyciwygChannel::AsyncOpen(nsIStreamListener * aListener, nsISupports * aContext)
nsWyciwygChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctx)
{
LOG(("nsWyciwygChannel::AsyncOpen [this=%x]\n", this));
NS_ENSURE_ARG_POINTER(aListener);
NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);
NS_ENSURE_ARG_POINTER(listener);
//XXX Should I worry about Port safety?
nsCAutoString spec;
mURI->GetSpec(spec);
// open a cache entry for this channel...
PRBool delayed = PR_FALSE;
nsresult rv = OpenCacheEntry(spec.get(), nsICache::ACCESS_READ, &delayed);
if (NS_FAILED(rv)) {
LOG(("nsWyciwygChannel::OpenCacheEntry failed [rv=%x]\n", rv));
return rv;
}
if (!delayed) {
rv = ReadFromCache();
if (NS_FAILED(rv)) {
LOG(("nsWyciwygChannel::ReadFromCache failed [rv=%x]\n", rv));
return rv;
}
}
mIsPending = PR_TRUE;
mListener = aListener;
mListenerContext = aContext;
mListener = listener;
mListenerContext = ctx;
// add ourselves to the load group. From this point forward, we'll report
// all failures asynchronously.
if (mLoadGroup)
mLoadGroup->AddRequest(this, nsnull);
nsresult rv = Connect(PR_TRUE);
if (NS_FAILED(rv)) {
LOG(("nsWyciwygChannel::AsyncOpen Connect failed [rv=%x]\n", rv));
CloseCacheEntry();
AsyncAbort(rv);
}
return NS_OK;
}
@ -357,12 +331,8 @@ nsWyciwygChannel::WriteToCacheEntry(const nsACString &aScript)
}
if (!mCacheOutputStream) {
//Get the transport from cache
rv = mCacheEntry->GetTransport(getter_AddRefs(mCacheTransport));
if (NS_FAILED(rv)) return rv;
// Get the outputstream from the transport.
rv = mCacheTransport->OpenOutputStream(0, PRUint32(-1), 0, getter_AddRefs(mCacheOutputStream));
// Get the outputstream from the cache entry.
rv = mCacheEntry->OpenOutputStream(0, getter_AddRefs(mCacheOutputStream));
if (NS_FAILED(rv)) return rv;
}
@ -372,20 +342,19 @@ nsWyciwygChannel::WriteToCacheEntry(const nsACString &aScript)
NS_IMETHODIMP
nsWyciwygChannel::CloseCacheEntry()
nsWyciwygChannel::CloseCacheEntry(nsresult reason)
{
nsresult rv = NS_OK;
if (mCacheEntry) {
LOG(("nsWyciwygChannel::CloseCacheEntry [this=%x ]", this));
// make sure the cache transport isn't holding a reference back to us
if (mCacheTransport)
mCacheTransport->SetNotificationCallbacks(nsnull, 0);
mCacheReadRequest = 0;
mCacheTransport = 0;
mCacheOutputStream = 0;
mCacheInputStream = 0;
if (NS_FAILED(reason))
mCacheEntry->Doom();
mCacheEntry = 0;
}
return rv;
return NS_OK;
}
//////////////////////////////////////////////////////////////////////////////
@ -403,26 +372,39 @@ nsWyciwygChannel::OnCacheEntryAvailable(nsICacheEntryDescriptor * aCacheEntry, n
return NS_OK;
// otherwise, we have to handle this event.
if (NS_SUCCEEDED(aStatus)) {
mCacheEntry = aCacheEntry;
}
if (NS_SUCCEEDED(aStatus))
mCacheEntry = aCacheEntry;
else if (NS_SUCCEEDED(mStatus))
mStatus = aStatus;
nsresult rv;
if (NS_FAILED(mStatus)) {
LOG(("channel was canceled [this=%x status=%x]\n", this, mStatus));
rv = mStatus;
}
else // advance to the next state...
rv = Connect(PR_FALSE);
else { // advance to the next state...
rv = ReadFromCache();
}
// a failure from Connect means that we have to abort the channel.
if (NS_FAILED(rv)) {
CloseCacheEntry();
AsyncAbort(rv);
CloseCacheEntry(rv);
if (mListener) {
mListener->OnStartRequest(this, mListenerContext);
mListener->OnStopRequest(this, mListenerContext, mStatus);
mListener = 0;
mListenerContext = 0;
}
mIsPending = PR_FALSE;
// Remove ourselves from the load group.
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nsnull, mStatus);
}
return rv;
return NS_OK;
}
//-----------------------------------------------------------------------------
@ -430,24 +412,21 @@ nsWyciwygChannel::OnCacheEntryAvailable(nsICacheEntryDescriptor * aCacheEntry, n
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsWyciwygChannel::OnDataAvailable(nsIRequest *aRequest, nsISupports *aCtxt,
nsIInputStream *aInput,
PRUint32 aOffset, PRUint32 aCount)
nsWyciwygChannel::OnDataAvailable(nsIRequest *request, nsISupports *ctx,
nsIInputStream *input,
PRUint32 offset, PRUint32 count)
{
LOG(("nsWyciwygChannel::OnDataAvailable [this=%x request=%x offset=%u count=%u]\n",
this, aRequest, aOffset, aCount));
this, request, offset, count));
// if the request is for something we no longer reference, then simply
// drop this event.
if (aRequest != mCacheReadRequest) {
NS_WARNING("nsWyciwygChannel::OnDataAvailable got stale request... why wasn't it cancelled?");
return NS_BASE_STREAM_CLOSED;
}
nsresult rv;
rv = mListener->OnDataAvailable(this, mListenerContext, input, offset, count);
if (mListener)
return mListener->OnDataAvailable((nsIRequest *)this, mListenerContext, aInput, aOffset, aCount);
if (mProgressSink && NS_SUCCEEDED(rv) && !(mLoadFlags & LOAD_BACKGROUND))
mProgressSink->OnProgress(this, nsnull, offset + count, mContentLength);
return NS_BASE_STREAM_CLOSED;
return rv; // let the pump cancel on failure
}
//////////////////////////////////////////////////////////////////////////////
@ -455,70 +434,41 @@ nsWyciwygChannel::OnDataAvailable(nsIRequest *aRequest, nsISupports *aCtxt,
//////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsWyciwygChannel::OnStartRequest(nsIRequest *aRequest, nsISupports *aCtxt)
nsWyciwygChannel::OnStartRequest(nsIRequest *request, nsISupports *ctx)
{
nsresult rv = NS_ERROR_FAILURE;
LOG(("nsWyciwygChannel::OnStartRequest [this=%x request=%x\n",
this, aRequest));
this, request));
// capture the request's status, so our consumers will know ASAP of any
// connection failures, etc.
aRequest->GetStatus(&mStatus);
if (mListener)
rv = mListener->OnStartRequest(this, mListenerContext);
return rv;
return mListener->OnStartRequest(this, mListenerContext);
}
NS_IMETHODIMP
nsWyciwygChannel::OnStopRequest(nsIRequest *aRequest, nsISupports *aCtxt, nsresult aStatus)
nsWyciwygChannel::OnStopRequest(nsIRequest *request, nsISupports *ctx, nsresult status)
{
LOG(("nsWyciwygChannel::OnStopRequest [this=%x request=%x status=%d\n",
this, aRequest, (PRUint32)aStatus));
mIsPending = PR_FALSE;
mStatus = aStatus;
CloseCacheEntry();
if (mListener) {
mListener->OnStopRequest(this, mListenerContext, aStatus);
mListener = 0;
mListenerContext = 0;
}
this, request, status));
if (NS_SUCCEEDED(mStatus))
mStatus = status;
mListener->OnStopRequest(this, mListenerContext, mStatus);
mListener = 0;
mListenerContext = 0;
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nsnull, aStatus);
mLoadGroup->RemoveRequest(this, nsnull, mStatus);
CloseCacheEntry(mStatus);
mPump = 0;
mIsPending = PR_FALSE;
return NS_OK;
}
//////////////////////////////////////////////////////////////////////////////
// nsIProgressEventSink
//////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsWyciwygChannel::OnStatus(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatus,
const PRUnichar *aStatusText)
{
if (mProgressSink)
mProgressSink->OnStatus(this, mListenerContext, aStatus, aStatusText);
return NS_OK;
}
NS_IMETHODIMP
nsWyciwygChannel::OnProgress(nsIRequest *aRequest, nsISupports *aContext,
PRUint32 aProgress, PRUint32 aProgressMax)
{
if (mProgressSink)
mProgressSink->OnProgress(this, mListenerContext, aProgress, aProgressMax);
return NS_OK;
}
//////////////////////////////////////////////////////////////////////////////
// Helper functions
//////////////////////////////////////////////////////////////////////////////
nsresult
nsWyciwygChannel::OpenCacheEntry(const char * aCacheKey, nsCacheAccessMode aAccessMode, PRBool * aDelayFlag )
{
@ -567,77 +517,25 @@ nsWyciwygChannel::OpenCacheEntry(const char * aCacheKey, nsCacheAccessMode aAcce
return rv;
}
nsresult
nsWyciwygChannel::Connect(PRBool aFirstTime)
{
nsresult rv = NS_ERROR_FAILURE;
LOG(("nsWyciwygChannel::Connect [this=%x]\n", this));
// true when called from AsyncOpen
if (aFirstTime) {
PRBool delayed = PR_FALSE;
nsCAutoString spec;
mURI->GetSpec(spec);
// open a cache entry for this channel...
rv = OpenCacheEntry(spec.get(), nsICache::ACCESS_READ, &delayed);
if (NS_FAILED(rv)) {
LOG(("nsWyciwygChannel::Connect OpenCacheEntry failed [rv=%x]\n", rv));
return rv;
}
if (NS_SUCCEEDED(rv) && delayed)
return NS_OK;
}
// Read the script from cache.
if (mCacheEntry)
return ReadFromCache();
return rv;
}
nsresult
nsWyciwygChannel::ReadFromCache()
{
nsresult rv;
NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_FAILURE);
LOG(("nsWyciwygChannel::ReadFromCache [this=%x] ", this));
// Get a transport to the cached data...
rv = mCacheEntry->GetTransport(getter_AddRefs(mCacheTransport));
if (NS_FAILED(rv) || !mCacheTransport)
return rv;
NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_FAILURE);
nsresult rv;
// Hookup the notification callbacks interface to the new transport...
mCacheTransport->SetNotificationCallbacks(this,
((mLoadFlags & nsIRequest::LOAD_BACKGROUND)
? nsITransport::DONT_REPORT_PROGRESS
: 0));
// Get a transport to the cached data...
rv = mCacheEntry->OpenInputStream(0, getter_AddRefs(mCacheInputStream));
if (NS_FAILED(rv))
return rv;
NS_ENSURE_TRUE(mCacheInputStream, NS_ERROR_UNEXPECTED);
rv = NS_NewInputStreamPump(getter_AddRefs(mPump), mCacheInputStream, -1);
if (NS_FAILED(rv)) return rv;
// Pump the cache data downstream
return mCacheTransport->AsyncRead(this, nsnull,
0, PRUint32(-1), 0,
getter_AddRefs(mCacheReadRequest));
return mPump->AsyncRead(this, nsnull);
}
// called when Connect fails
nsresult
nsWyciwygChannel::AsyncAbort(nsresult aStatus)
{
LOG(("nsWyciwygChannel::AsyncAbort [this=%x status=%x]\n", this, aStatus));
mStatus = aStatus;
mIsPending = PR_FALSE;
// Remove ourselves from the load group.
if (mLoadGroup)
mLoadGroup->RemoveRequest((nsIRequest *)this, nsnull, aStatus);
return NS_OK;
}
// vim: ts=2 sw=2

67
content/html/document/src/nsWyciwygChannel.h
Просмотреть файл

@ -23,76 +23,73 @@
#ifndef nsWyciwygChannel_h___
#define nsWyciwygChannel_h___
#include "nsIWyciwygChannel.h"
#include "nsString.h"
#include "nsILoadGroup.h"
#include "nsIInputStream.h"
#include "nsIInterfaceRequestor.h"
#include "nsCOMPtr.h"
#include "nsXPIDLString.h"
#include "nsIChannel.h"
#include "nsIURI.h"
#include "nsWyciwygProtocolHandler.h"
#include "nsXPIDLString.h"
#include "nsString.h"
#include "nsCOMPtr.h"
#include "prlog.h"
#include "nsIWyciwygChannel.h"
#include "nsILoadGroup.h"
#include "nsIOutputStream.h"
#include "nsIInputStream.h"
#include "nsIInputStreamPump.h"
#include "nsIInterfaceRequestor.h"
#include "nsIProgressEventSink.h"
#include "nsIStreamListener.h"
#include "nsICacheListener.h"
#include "nsITransport.h"
#include "nsICacheEntryDescriptor.h"
#include "nsIOutputStream.h"
#include "nsIProgressEventSink.h"
#include "prlog.h"
#include "nsIURI.h"
extern PRLogModuleInfo * gWyciwygLog;
#define LOG(args) PR_LOG(gWyciwygLog, 4, args)
//-----------------------------------------------------------------------------
class nsWyciwygChannel: public nsIWyciwygChannel,
class nsWyciwygChannel: public nsIWyciwygChannel,
public nsIStreamListener,
public nsIInterfaceRequestor,
public nsICacheListener,
public nsIProgressEventSink
public nsICacheListener
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIREQUEST
NS_DECL_NSICHANNEL
NS_DECL_NSIWYCIWYGCHANNEL
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSISTREAMLISTENER
NS_DECL_NSICACHELISTENER
NS_DECL_NSIINTERFACEREQUESTOR
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSIPROGRESSEVENTSINK
// nsWyciwygChannel methods:
nsWyciwygChannel();
virtual ~nsWyciwygChannel();
nsresult Init(nsIURI* uri);
nsresult Init(nsIURI *uri);
protected:
nsresult AsyncAbort(nsresult rv);
nsresult Connect(PRBool firstTime);
nsresult ReadFromCache();
nsresult OpenCacheEntry(const char * aCacheKey, nsCacheAccessMode aWriteAccess, PRBool * aDelayFlag = nsnull);
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsIURI> mOriginalURI;
nsCOMPtr<nsISupports> mOwner;
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsIProgressEventSink> mProgressSink;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsIStreamListener> mListener;
nsCOMPtr<nsISupports> mListenerContext;
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsIProgressEventSink> mProgressSink;
nsCString mContentType;
nsCString mContentCharset;
PRInt32 mContentLength;
PRUint32 mLoadFlags;
nsresult mStatus;
PRBool mIsPending;
// reuse as much of this channel implementation as we can
nsCOMPtr<nsIInputStreamPump> mPump;
// Cache related stuff
nsCOMPtr<nsITransport> mCacheTransport;
nsCOMPtr<nsIRequest> mCacheReadRequest;
nsCOMPtr<nsICacheEntryDescriptor> mCacheEntry;
nsCOMPtr<nsIOutputStream> mCacheOutputStream;
// flags
PRUint32 mStatus;
PRUint32 mLoadFlags;
PRPackedBool mIsPending;
nsCOMPtr<nsIInputStream> mCacheInputStream;
};
#endif /* nsWyciwygChannel_h___ */

12
docshell/base/nsDocShell.cpp
Просмотреть файл

@ -729,13 +729,12 @@ nsDocShell::LoadURI(nsIURI * aURI,
}
NS_IMETHODIMP
nsDocShell::LoadStream(nsIInputStream * aStream, nsIURI * aURI,
const char *aContentType, PRInt32 aContentLen,
nsDocShell::LoadStream(nsIInputStream *aStream, nsIURI * aURI,
const nsACString &aContentType,
const nsACString &aContentCharset,
nsIDocShellLoadInfo * aLoadInfo)
{
NS_ENSURE_ARG(aStream);
NS_ENSURE_ARG(aContentType);
NS_ENSURE_ARG(aContentLen);
// if the caller doesn't pass in a URI we need to create a dummy URI. necko
// currently requires a URI in various places during the load. Some consumers
@ -770,9 +769,8 @@ nsDocShell::LoadStream(nsIInputStream * aStream, nsIURI * aURI,
nsCOMPtr<nsIChannel> channel;
NS_ENSURE_SUCCESS(NS_NewInputStreamChannel
(getter_AddRefs(channel), uri, aStream,
nsDependentCString(aContentType),
NS_LITERAL_CSTRING(""),
aContentLen), NS_ERROR_FAILURE);
aContentType, aContentCharset),
NS_ERROR_FAILURE);
nsCOMPtr<nsIURILoader>
uriLoader(do_GetService(NS_URI_LOADER_CONTRACTID));

28
docshell/base/nsIDocShell.idl
Просмотреть файл

@ -77,23 +77,23 @@ interface nsIDocShell : nsISupports
* here however, the URL dispatched will go through its normal process of
* content loading.
*
* @param aStream - The input stream that provides access to the data
* to be loaded.
* @param aURI - The URI representing the stream, or null.
* @param aContentType - The type (MIME) of data being loaded.
* @param aContentLen - The length (in bytes) of the stream. If you don't
* know the length of the stream this can be -1.
* @param aLoadInfo - This is the extended load info for this load. This
* most often will be null, but if you need to do
* additional setup for this load you can get a
* loadInfo object by calling createLoadInfo. Once
* you have this object you can set the needed
* properties on it and then pass it to loadStream.
* @param aStream - The input stream that provides access to the data
* to be loaded. This must be a blocking, threadsafe
* stream implementation.
* @param aURI - The URI representing the stream, or null.
* @param aContentType - The type (MIME) of data being loaded (empty if unknown).
* @param aContentCharset - The charset of the data being loaded (empty if unknown).
* @param aLoadInfo - This is the extended load info for this load. This
* most often will be null, but if you need to do
* additional setup for this load you can get a
* loadInfo object by calling createLoadInfo. Once
* you have this object you can set the needed
* properties on it and then pass it to loadStream.
*/
[noscript]void loadStream(in nsIInputStream aStream,
in nsIURI aURI,
in string aContentType,
in long aContentLen,
in ACString aContentType,
in ACString aContentCharset,
in nsIDocShellLoadInfo aLoadInfo);
/**

110
dom/src/jsurl/nsJSProtocolHandler.cpp
Просмотреть файл

@ -57,7 +57,7 @@
#include "nsICodebasePrincipal.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsIByteArrayInputStream.h"
#include "nsIStringStream.h"
#include "nsIWindowMediator.h"
#include "nsIDOMWindowInternal.h"
#include "nsIDOMDocument.h"
@ -72,13 +72,13 @@ static NS_DEFINE_CID(kWindowMediatorCID, NS_WINDOWMEDIATOR_CID);
class nsJSThunk : public nsIStreamIO
class nsJSThunk : public nsIInputStream
{
public:
nsJSThunk();
NS_DECL_ISUPPORTS
NS_DECL_NSISTREAMIO
NS_FORWARD_SAFE_NSIINPUTSTREAM(mInnerStream)
nsresult Init(nsIURI* uri);
nsresult EvaluateScript(nsIChannel *aChannel);
@ -88,24 +88,21 @@ protected:
virtual ~nsJSThunk();
nsCOMPtr<nsIURI> mURI;
char* mResult;
PRUint32 mLength;
nsCOMPtr<nsIInputStream> mInnerStream;
};
//
// nsISupports implementation...
//
NS_IMPL_THREADSAFE_ISUPPORTS1(nsJSThunk, nsIStreamIO);
NS_IMPL_THREADSAFE_ISUPPORTS1(nsJSThunk, nsIInputStream);
nsJSThunk::nsJSThunk()
: mResult(nsnull), mLength(0)
{
}
nsJSThunk::~nsJSThunk()
{
(void)Close(NS_BASE_STREAM_CLOSED);
}
nsresult nsJSThunk::Init(nsIURI* uri)
@ -289,9 +286,9 @@ nsresult nsJSThunk::EvaluateScript(nsIChannel *aChannel)
rv = NS_ERROR_DOM_RETVAL_UNDEFINED;
}
else {
// NS_NewStringInputStream calls ToNewCString
// XXXbe this should not decimate! pass back UCS-2 to necko
mResult = ToNewCString(result);
mLength = result.Length();
rv = NS_NewStringInputStream(getter_AddRefs(mInnerStream), result);
}
return rv;
}
@ -325,87 +322,6 @@ nsresult nsJSThunk::BringUpConsole(nsIDOMWindow *aDomWindow)
return rv;
}
//
// nsIStreamIO implementation...
//
NS_IMETHODIMP
nsJSThunk::Open()
{
return NS_OK;
}
NS_IMETHODIMP
nsJSThunk::GetContentType(nsACString &aContentType)
{
//
// At this point the script has already been evaluated...
// The resulting string (if any) is stored in mResult.
//
// If the resultant script evaluation actually does return a value, we
// treat it as html.
//
aContentType = NS_LITERAL_CSTRING("text/html");
return NS_OK;
}
NS_IMETHODIMP
nsJSThunk::GetContentCharset(nsACString &aContentCharset)
{
aContentCharset.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsJSThunk::GetContentLength(PRInt32 *result)
{
*result = mLength;
return NS_OK;
}
NS_IMETHODIMP
nsJSThunk::Close(nsresult status)
{
if (mResult) {
nsCRT::free(mResult);
mResult = nsnull;
}
mLength = 0;
return NS_OK;
}
NS_IMETHODIMP
nsJSThunk::GetInputStream(nsIInputStream* *aInputStream)
{
nsresult rv;
nsIByteArrayInputStream* str;
rv = NS_NewByteArrayInputStream(&str, mResult, mLength);
if (NS_SUCCEEDED(rv)) {
mResult = nsnull; // XXX Whackiness. The input stream takes ownership
*aInputStream = str;
}
else {
*aInputStream = nsnull;
}
return rv;
}
NS_IMETHODIMP
nsJSThunk::GetOutputStream(nsIOutputStream* *aOutputStream)
{
// should never be called
NS_NOTREACHED("nsJSThunk::GetOutputStream");
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsJSThunk::GetName(nsACString &aName)
{
return mURI->GetSpec(aName);
}
////////////////////////////////////////////////////////////////////////////////
class nsJSChannel : public nsIChannel
@ -454,17 +370,21 @@ nsresult nsJSChannel::Init(nsIURI *aURI)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(mIOThunk);
// Create a stock nsIStreamIOChannel...
// Create a stock input stream channel...
// Remember, until AsyncOpen is called, the script will not be evaluated
// and the underlying Input Stream will not be created...
nsCOMPtr<nsIStreamIOChannel> channel;
nsCOMPtr<nsIChannel> channel;
rv = NS_NewStreamIOChannel(getter_AddRefs(channel), aURI, mIOThunk);
// If the resultant script evaluation actually does return a value, we
// treat it as html.
rv = NS_NewInputStreamChannel(getter_AddRefs(channel), aURI, mIOThunk,
NS_LITERAL_CSTRING("text/html"),
NS_LITERAL_CSTRING(""));
if (NS_FAILED(rv)) return rv;
rv = mIOThunk->Init(aURI);
if (NS_SUCCEEDED(rv)) {
mStreamChannel = do_QueryInterface(channel);
mStreamChannel = channel;
}
return rv;

3
embedding/browser/gtk/src/EmbedStream.cpp
Просмотреть файл

@ -117,8 +117,7 @@ EmbedStream::OpenStream(const char *aBaseURI, const char *aContentType)
rv = NS_NewInputStreamChannel(getter_AddRefs(mChannel), uri,
NS_STATIC_CAST(nsIInputStream *, this),
nsDependentCString(aContentType),
NS_LITERAL_CSTRING(""),
1024); /* len */
NS_LITERAL_CSTRING(""));
if (NS_FAILED(rv))
return rv;

4
embedding/components/webbrowserpersist/src/nsWebBrowserPersist.cpp
Просмотреть файл

@ -35,7 +35,6 @@
#include "nsNetUtil.h"
#include "nsComponentManagerUtils.h"
#include "nsIFileTransportService.h"
#include "nsIStorageStream.h"
#include "nsIHttpChannel.h"
#include "nsIEncodedChannel.h"
@ -85,7 +84,7 @@
#include "nsIDOMHTMLDocument.h"
#include "ftpCore.h"
#include "nsISocketTransportService.h"
#include "nsISocketTransport.h"
#include "nsIStringBundle.h"
#include "nsWebBrowserPersist.h"
@ -900,7 +899,6 @@ NS_IMETHODIMP nsWebBrowserPersist::OnStatus(
case NS_NET_STATUS_CONNECTED_TO:
case NS_NET_STATUS_SENDING_TO:
case NS_NET_STATUS_RECEIVING_FROM:
case NS_NET_STATUS_READ_FROM:
break;
default:

1
extensions/datetime/Makefile.in
Просмотреть файл

@ -51,6 +51,7 @@ MODULE_NAME = datetime
REQUIRES = xpcom \
string \
necko \
mimetype \
$(NULL)
CPPSRCS = \

337
extensions/datetime/nsDateTimeChannel.cpp
Просмотреть файл

@ -1,122 +1,111 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
/* -*- 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 the License at
* http://www.mozilla.org/NPL/
* The contents of this file are subject to the Mozilla 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/MPL/
*
* 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.
* 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 the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
* The Initial Developer of the Original Code is Brian Ryner.
* Portions created by Brian Ryner are Copyright (C) 2000 Brian Ryner.
* All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the NPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
* Contributor(s):
* Brian Ryner <bryner@uiuc.edu>
*/
// datetime implementation
// DateTime implementation
#include "nsDateTimeChannel.h"
#include "nsNetUtil.h"
#include "nsIServiceManager.h"
#include "nsILoadGroup.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsXPIDLString.h"
#include "nsISocketTransportService.h"
#include "nsITransport.h"
#include "nsIStringStream.h"
#include "nsMimeTypes.h"
#include "nsIStreamConverterService.h"
#include "nsITXTToHTMLConv.h"
#include "nsIProgressEventSink.h"
#include "nsEventQueueUtils.h"
#include "nsNetUtil.h"
#include "nsCRT.h"
static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID);
static NS_DEFINE_CID(kStreamConverterServiceCID, NS_STREAMCONVERTERSERVICE_CID);
// nsDateTimeChannel methods
nsDateTimeChannel::nsDateTimeChannel() {
mContentLength = -1;
mPort = -1;
nsDateTimeChannel::nsDateTimeChannel()
: mLoadFlags(LOAD_NORMAL)
, mStatus(NS_OK)
, mPort(-1)
{
}
nsDateTimeChannel::~nsDateTimeChannel() {
nsDateTimeChannel::~nsDateTimeChannel()
{
}
NS_IMPL_ISUPPORTS4(nsDateTimeChannel,
nsIChannel,
nsIRequest,
nsIRequest,
nsIStreamListener,
nsIRequestObserver)
nsresult
nsDateTimeChannel::Init(nsIURI* uri, nsIProxyInfo* proxyInfo)
nsDateTimeChannel::Init(nsIURI *uri, nsIProxyInfo *proxyInfo)
{
nsresult rv;
NS_ASSERTION(uri, "no uri");
mUrl = uri;
mURI = uri;
mProxyInfo = proxyInfo;
rv = mUrl->GetPort(&mPort);
rv = mURI->GetPort(&mPort);
if (NS_FAILED(rv) || mPort < 1)
mPort = DATETIME_PORT;
rv = mUrl->GetPath(mHost);
rv = mURI->GetPath(mHost);
if (NS_FAILED(rv)) return rv;
if (!*(const char *)mHost) return NS_ERROR_NOT_INITIALIZED;
if (mHost.IsEmpty())
return NS_ERROR_MALFORMED_URI;
mContentType = NS_LITERAL_CSTRING(TEXT_HTML); // expected content-type
return NS_OK;
}
NS_METHOD
nsDateTimeChannel::Create(nsISupports* aOuter, const nsIID& aIID, void* *aResult)
{
nsDateTimeChannel* dc = new nsDateTimeChannel();
if (dc == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(dc);
nsresult rv = dc->QueryInterface(aIID, aResult);
NS_RELEASE(dc);
return rv;
}
////////////////////////////////////////////////////////////////////////////////
// nsIRequest methods:
NS_IMETHODIMP
nsDateTimeChannel::GetName(nsACString &result)
{
return NS_ERROR_NOT_IMPLEMENTED;
return mURI->GetSpec(result);
}
NS_IMETHODIMP
nsDateTimeChannel::IsPending(PRBool *result)
{
NS_NOTREACHED("nsDateTimeChannel::IsPending");
return NS_ERROR_NOT_IMPLEMENTED;
*result = (mPump != nsnull);
return NS_OK;
}
NS_IMETHODIMP
nsDateTimeChannel::GetStatus(nsresult *status)
{
*status = NS_OK;
if (NS_SUCCEEDED(mStatus) && mPump)
mPump->GetStatus(status);
else
*status = mStatus;
return NS_OK;
}
@ -124,22 +113,28 @@ NS_IMETHODIMP
nsDateTimeChannel::Cancel(nsresult status)
{
NS_ASSERTION(NS_FAILED(status), "shouldn't cancel with a success code");
NS_NOTREACHED("nsDateTimeChannel::Cancel");
return NS_ERROR_NOT_IMPLEMENTED;
mStatus = status;
if (mPump)
mPump->Cancel(status);
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
nsDateTimeChannel::Suspend(void)
nsDateTimeChannel::Suspend()
{
NS_NOTREACHED("nsDateTimeChannel::Suspend");
return NS_ERROR_NOT_IMPLEMENTED;
if (mPump)
mPump->Suspend();
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
nsDateTimeChannel::Resume(void)
nsDateTimeChannel::Resume()
{
NS_NOTREACHED("nsDateTimeChannel::Resume");
return NS_ERROR_NOT_IMPLEMENTED;
if (mPump)
mPump->Resume();
return NS_ERROR_UNEXPECTED;
}
////////////////////////////////////////////////////////////////////////////////
@ -148,7 +143,7 @@ nsDateTimeChannel::Resume(void)
NS_IMETHODIMP
nsDateTimeChannel::GetOriginalURI(nsIURI* *aURI)
{
*aURI = mOriginalURI ? mOriginalURI : mUrl;
*aURI = mOriginalURI ? mOriginalURI : mURI;
NS_ADDREF(*aURI);
return NS_OK;
}
@ -163,7 +158,7 @@ nsDateTimeChannel::SetOriginalURI(nsIURI* aURI)
NS_IMETHODIMP
nsDateTimeChannel::GetURI(nsIURI* *aURI)
{
*aURI = mUrl;
*aURI = mURI;
NS_IF_ADDREF(*aURI);
return NS_OK;
}
@ -171,58 +166,84 @@ nsDateTimeChannel::GetURI(nsIURI* *aURI)
NS_IMETHODIMP
nsDateTimeChannel::Open(nsIInputStream **_retval)
{
nsresult rv = NS_OK;
rv = NS_CheckPortSafety(mPort, "datetime");
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsISocketTransportService> sts =
do_GetService("@mozilla.org/network/socket-transport-service;1", &rv);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsITransport> transport;
rv = sts->CreateTransport(mHost,
mPort,
mProxyInfo,
32,
32,
getter_AddRefs(transport));
if (NS_FAILED(rv)) return rv;
transport->SetNotificationCallbacks(mCallbacks,
(mLoadFlags & LOAD_BACKGROUND));
return transport->OpenInputStream(0, PRUint32(-1), 0, _retval);
NS_NOTREACHED("nsDateTimeChannel::Open");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDateTimeChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *ctxt)
{
nsresult rv = NS_OK;
rv = NS_CheckPortSafety(mPort, "datetime");
if (NS_FAILED(rv))
return rv;
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIEventQueue> eventQ;
rv = NS_GetCurrentEventQ(getter_AddRefs(eventQ));
if (NS_FAILED(rv)) return rv;
//
// create transport
//
nsCOMPtr<nsISocketTransportService> sts =
do_GetService("@mozilla.org/network/socket-transport-service;1", &rv);
do_GetService(kSocketTransportServiceCID, &rv);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsITransport> transport;
rv = sts->CreateTransport(mHost,
mPort,
mProxyInfo,
32,
32,
getter_AddRefs(transport));
rv = sts->CreateTransport(nsnull, 0, mHost, mPort, mProxyInfo,
getter_AddRefs(mTransport));
if (NS_FAILED(rv)) return rv;
transport->SetNotificationCallbacks(mCallbacks,
(mLoadFlags & LOAD_BACKGROUND));
// not fatal if these fail
mTransport->SetSecurityCallbacks(mCallbacks);
mTransport->SetEventSink(this, eventQ);
//
// create TXT to HTML stream converter
//
nsCOMPtr<nsIStreamConverterService> scs =
do_GetService(kStreamConverterServiceCID, &rv);
if (NS_FAILED(rv)) return rv;
NS_NAMED_LITERAL_STRING(fromStr, "text/plain");
NS_NAMED_LITERAL_STRING(toStr, "text/html");
nsCOMPtr<nsIStreamListener> convListener;
rv = scs->AsyncConvertData(fromStr.get(), toStr.get(), this, nsnull,
getter_AddRefs(convListener));
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsITXTToHTMLConv> conv = do_QueryInterface(convListener);
if (conv) {
nsCAutoString userHost;
rv = mURI->GetPath(userHost);
nsAutoString title;
title = NS_LITERAL_STRING("DateTime according to ")
+ NS_ConvertUTF8toUCS2(mHost);
conv->SetTitle(title.get());
conv->PreFormatHTML(PR_TRUE);
}
//
// open input stream, and create input stream pump...
//
nsCOMPtr<nsIInputStream> sockIn;
rv = mTransport->OpenInputStream(0, 0, 0, getter_AddRefs(sockIn));
if (NS_FAILED(rv)) return rv;
rv = NS_NewInputStreamPump(getter_AddRefs(mPump), sockIn);
if (NS_FAILED(rv)) return rv;
rv = mPump->AsyncRead(convListener, nsnull);
if (NS_FAILED(rv)) return rv;
if (mLoadGroup)
mLoadGroup->AddRequest(this, nsnull);
mListener = aListener;
nsCOMPtr<nsIRequest> request;
return transport->AsyncRead(this, ctxt, 0, PRUint32(-1), 0, getter_AddRefs(request));
mListenerContext = ctxt;
return NS_OK;
}
NS_IMETHODIMP
@ -239,49 +260,46 @@ nsDateTimeChannel::SetLoadFlags(PRUint32 aLoadFlags)
return NS_OK;
}
#define DATETIME_TYPE "text/plain"
NS_IMETHODIMP
nsDateTimeChannel::GetContentType(nsACString &aContentType)
{
aContentType = NS_LITERAL_CSTRING(DATETIME_TYPE);
aContentType = mContentType;
return NS_OK;
}
NS_IMETHODIMP
nsDateTimeChannel::SetContentType(const nsACString &aContentType)
{
// It doesn't make sense to set the content-type on this type
// of channel...
return NS_ERROR_FAILURE;
mContentType = aContentType;
return NS_OK;
}
NS_IMETHODIMP
nsDateTimeChannel::GetContentCharset(nsACString &aContentCharset)
{
aContentCharset.Truncate();
aContentCharset = mContentCharset;
return NS_OK;
}
NS_IMETHODIMP
nsDateTimeChannel::SetContentCharset(const nsACString &aContentCharset)
{
NS_NOTREACHED("nsDateTimeChannel::SetContentCharset");
return NS_ERROR_NOT_IMPLEMENTED;
mContentCharset = aContentCharset;
return NS_OK;
}
NS_IMETHODIMP
nsDateTimeChannel::GetContentLength(PRInt32 *aContentLength)
{
*aContentLength = mContentLength;
*aContentLength = -1;
return NS_OK;
}
NS_IMETHODIMP
nsDateTimeChannel::SetContentLength(PRInt32 aContentLength)
{
NS_NOTREACHED("nsDateTimeChannel::SetContentLength");
return NS_ERROR_NOT_IMPLEMENTED;
// silently ignore this...
return NS_OK;
}
NS_IMETHODIMP
@ -295,13 +313,7 @@ nsDateTimeChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
NS_IMETHODIMP
nsDateTimeChannel::SetLoadGroup(nsILoadGroup* aLoadGroup)
{
if (mLoadGroup) // if we already had a load group remove ourselves...
(void)mLoadGroup->RemoveRequest(this, nsnull, NS_OK);
mLoadGroup = aLoadGroup;
if (mLoadGroup) {
return mLoadGroup->AddRequest(this, nsnull);
}
return NS_OK;
}
@ -332,40 +344,73 @@ NS_IMETHODIMP
nsDateTimeChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aNotificationCallbacks)
{
mCallbacks = aNotificationCallbacks;
mProgressSink = do_GetInterface(mCallbacks);
return NS_OK;
}
NS_IMETHODIMP
nsDateTimeChannel::GetSecurityInfo(nsISupports **sec)
NS_IMETHODIMP
nsDateTimeChannel::GetSecurityInfo(nsISupports **aSecurityInfo)
{
NS_ENSURE_ARG_POINTER(sec);
*sec = nsnull;
if (mTransport)
return mTransport->GetSecurityInfo(aSecurityInfo);
*aSecurityInfo = nsnull;
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsIRequestObserver methods
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsDateTimeChannel::OnStartRequest(nsIRequest *request, nsISupports *aContext) {
return mListener->OnStartRequest(this, aContext);
nsDateTimeChannel::OnStartRequest(nsIRequest *req, nsISupports *ctx)
{
return mListener->OnStartRequest(this, mListenerContext);
}
NS_IMETHODIMP
nsDateTimeChannel::OnStopRequest(nsIRequest *req, nsISupports *ctx, nsresult status)
{
if (NS_SUCCEEDED(mStatus))
mStatus = status;
mListener->OnStopRequest(this, mListenerContext, mStatus);
mListener = 0;
mListenerContext = 0;
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nsnull, mStatus);
mPump = 0;
mTransport = 0;
return NS_OK;
}
NS_IMETHODIMP
nsDateTimeChannel::OnStopRequest(nsIRequest *request, nsISupports* aContext,
nsresult aStatus) {
if (mLoadGroup) {
nsresult rv = mLoadGroup->RemoveRequest(this, nsnull, aStatus);
if (NS_FAILED(rv)) return rv;
nsDateTimeChannel::OnDataAvailable(nsIRequest *req, nsISupports *ctx,
nsIInputStream *stream, PRUint32 offset,
PRUint32 count)
{
return mListener->OnDataAvailable(this, mListenerContext, stream, offset, count);
}
//-----------------------------------------------------------------------------
// nsITransportEventSink methods
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsDateTimeChannel::OnTransportStatus(nsITransport *trans, nsresult status,
PRUint32 progress, PRUint32 progressMax)
{
// suppress status notification if channel is no longer pending!
if (mProgressSink && mPump && !(mLoadFlags & LOAD_BACKGROUND)) {
NS_ConvertUTF8toUCS2 host(mHost);
mProgressSink->OnStatus(this, nsnull, status, host.get());
if (status == nsISocketTransport::STATUS_RECEIVING_FROM ||
status == nsISocketTransport::STATUS_SENDING_TO) {
mProgressSink->OnProgress(this, nsnull, progress, progressMax);
}
}
return mListener->OnStopRequest(this, aContext, aStatus);
}
// nsIStreamListener method
NS_IMETHODIMP
nsDateTimeChannel::OnDataAvailable(nsIRequest *request, nsISupports* aContext,
nsIInputStream *aInputStream, PRUint32 aSourceOffset,
PRUint32 aLength) {
mContentLength = aLength;
return mListener->OnDataAvailable(this, aContext, aInputStream, aSourceOffset, aLength);
return NS_OK;
}

100
extensions/datetime/nsDateTimeChannel.h
Просмотреть файл

@ -1,95 +1,85 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
/* -*- 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 the License at
* http://www.mozilla.org/NPL/
* The contents of this file are subject to the Mozilla 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/MPL/
*
* 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.
* 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 the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
* The Initial Developer of the Original Code is Brian Ryner.
* Portions created by Brian Ryner are Copyright (C) 2000 Brian Ryner.
* All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the NPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
* Contributor(s):
* Darin Fisher <darin@netscape.com>
*/
// A datetime channel retrieves date time information from
// RFC 867 compliant datetime servers. The date/time returned
// to the caller is of MIME type "text/plain".
#ifndef nsDateTimeChannel_h___
#define nsDateTimeChannel_h___
#ifndef nsDateTimeChannel_h__
#define nsDateTimeChannel_h__
#include "nsDateTimeHandler.h"
#include "nsString.h"
#include "nsCOMPtr.h"
#include "nsILoadGroup.h"
#include "nsIInputStream.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsCOMPtr.h"
#include "nsXPIDLString.h"
#include "nsIProgressEventSink.h"
#include "nsIInputStreamPump.h"
#include "nsIChannel.h"
#include "nsIURI.h"
#include "nsDateTimeHandler.h"
#include "nsIStreamListener.h"
#include "nsISocketTransport.h"
#include "nsIProxyInfo.h"
class nsDateTimeChannel
: public nsIChannel,
public nsIStreamListener {
//-----------------------------------------------------------------------------
class nsDateTimeChannel : public nsIChannel
, public nsIStreamListener
, public nsITransportEventSink
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIREQUEST
NS_DECL_NSICHANNEL
NS_DECL_NSISTREAMLISTENER
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSITRANSPORTEVENTSINK
// nsDateTimeChannel methods:
nsDateTimeChannel();
virtual ~nsDateTimeChannel();
// Define a Create method to be used with a factory:
static NS_METHOD
Create(nsISupports* aOuter, const nsIID& aIID, void* *aResult);
nsresult Init(nsIURI* uri, nsIProxyInfo* proxyInfo);
nsresult Init(nsIURI *uri, nsIProxyInfo *proxyInfo);
protected:
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsIURI> mOriginalURI;
nsCOMPtr<nsIURI> mUrl;
nsCOMPtr<nsIStreamListener> mListener;
PRUint32 mLoadFlags;
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsIProgressEventSink> mProgressSink;
nsCOMPtr<nsISupports> mOwner;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsIStreamListener> mListener;
nsCOMPtr<nsISupports> mListenerContext;
nsCString mContentType;
PRInt32 mContentLength;
nsCOMPtr<nsISupports> mOwner;
nsCString mContentCharset;
PRUint32 mLoadFlags;
nsresult mStatus;
nsCOMPtr<nsIInputStreamPump> mPump;
nsCOMPtr<nsISocketTransport> mTransport;
nsCOMPtr<nsIProxyInfo> mProxyInfo;
nsCString mHost;
PRInt32 mPort;
nsXPIDLCString mHost;
};
#endif /* nsDateTimeChannel_h___ */
#endif // !nsDateTimeChannel_h__

13
extensions/datetime/nsDateTimeHandler.cpp
Просмотреть файл

@ -128,17 +128,18 @@ nsDateTimeHandler::NewProxiedChannel(nsIURI* url, nsIProxyInfo* proxyInfo,
{
nsresult rv;
nsDateTimeChannel* channel;
rv = nsDateTimeChannel::Create(nsnull, NS_GET_IID(nsIChannel), (void**)&channel);
if (NS_FAILED(rv)) return rv;
nsDateTimeChannel *chan = new nsDateTimeChannel();
if (!chan)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(chan);
rv = channel->Init(url, proxyInfo);
rv = chan->Init(url, proxyInfo);
if (NS_FAILED(rv)) {
NS_RELEASE(channel);
NS_RELEASE(chan);
return rv;
}
*result = channel;
*result = chan;
return NS_OK;
}

360
extensions/finger/nsFingerChannel.cpp
Просмотреть файл

@ -17,7 +17,8 @@
* All Rights Reserved.
*
* Contributor(s):
* Brian Ryner <bryner@uiuc.edu>
* Brian Ryner <bryner@uiuc.edu>
* Darin Fisher <darin@netscape.com>
*/
// finger implementation
@ -34,6 +35,7 @@
#include "nsIStreamConverterService.h"
#include "nsITXTToHTMLConv.h"
#include "nsIProgressEventSink.h"
#include "nsEventQueueUtils.h"
#include "nsNetUtil.h"
#include "nsCRT.h"
@ -45,31 +47,31 @@ static NS_DEFINE_CID(kStreamConverterServiceCID, NS_STREAMCONVERTERSERVICE_CID);
// nsFingerChannel methods
nsFingerChannel::nsFingerChannel()
: mContentLength(-1),
mActAsObserver(PR_TRUE),
mPort(-1),
mStatus(NS_OK)
: mLoadFlags(LOAD_NORMAL)
, mStatus(NS_OK)
, mPort(-1)
{
}
nsFingerChannel::~nsFingerChannel() {
nsFingerChannel::~nsFingerChannel()
{
}
NS_IMPL_THREADSAFE_ISUPPORTS4(nsFingerChannel,
nsIChannel,
nsIRequest,
nsIStreamListener,
nsIRequestObserver)
NS_IMPL_ISUPPORTS4(nsFingerChannel,
nsIChannel,
nsIRequest,
nsIStreamListener,
nsIRequestObserver)
nsresult
nsFingerChannel::Init(nsIURI* uri, nsIProxyInfo* proxyInfo)
nsFingerChannel::Init(nsIURI *uri, nsIProxyInfo *proxyInfo)
{
nsresult rv;
nsCAutoString autoBuffer;
NS_ASSERTION(uri, "no uri");
mUrl = uri;
mURI = uri;
mProxyInfo = proxyInfo;
// For security reasons, we do not allow the user to specify a
@ -77,7 +79,7 @@ nsFingerChannel::Init(nsIURI* uri, nsIProxyInfo* proxyInfo)
mPort = FINGER_PORT;
rv = mUrl->GetPath(autoBuffer); // autoBuffer = user@host
rv = mURI->GetPath(autoBuffer); // autoBuffer = user@host
if (NS_FAILED(rv)) return rv;
// Now parse out the user and host
@ -86,49 +88,43 @@ nsFingerChannel::Init(nsIURI* uri, nsIProxyInfo* proxyInfo)
// Catch the case of just the host being given
if (!pos) {
mUser.Truncate();
mHost.Assign(buf);
} else {
mUser.Assign(buf,pos-buf);
mUser.Assign(buf, pos-buf);
mHost.Assign(pos+1); // ignore '@'
}
if (mHost.IsEmpty()) return NS_ERROR_NOT_INITIALIZED;
if (mHost.IsEmpty())
return NS_ERROR_MALFORMED_URI;
mContentType = NS_LITERAL_CSTRING(TEXT_HTML); // expected content-type
return NS_OK;
}
NS_METHOD
nsFingerChannel::Create(nsISupports* aOuter, const nsIID& aIID, void* *aResult)
{
nsFingerChannel* fc = new nsFingerChannel();
if (fc == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(fc);
nsresult rv = fc->QueryInterface(aIID, aResult);
NS_RELEASE(fc);
return rv;
}
////////////////////////////////////////////////////////////////////////////////
// nsIRequest methods:
NS_IMETHODIMP
nsFingerChannel::GetName(nsACString &result)
{
return NS_ERROR_NOT_IMPLEMENTED;
return mURI->GetSpec(result);
}
NS_IMETHODIMP
nsFingerChannel::IsPending(PRBool *result)
{
NS_NOTREACHED("nsFingerChannel::IsPending");
return NS_ERROR_NOT_IMPLEMENTED;
*result = (mPump != nsnull);
return NS_OK;
}
NS_IMETHODIMP
nsFingerChannel::GetStatus(nsresult *status)
{
*status = mStatus;
if (NS_SUCCEEDED(mStatus) && mPump)
mPump->GetStatus(status);
else
*status = mStatus;
return NS_OK;
}
@ -136,27 +132,28 @@ NS_IMETHODIMP
nsFingerChannel::Cancel(nsresult status)
{
NS_ASSERTION(NS_FAILED(status), "shouldn't cancel with a success code");
nsresult rv = NS_ERROR_FAILURE;
mStatus = status;
if (mTransportRequest) {
rv = mTransportRequest->Cancel(status);
}
return rv;
if (mPump)
mPump->Cancel(status);
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
nsFingerChannel::Suspend(void)
nsFingerChannel::Suspend()
{
NS_NOTREACHED("nsFingerChannel::Suspend");
return NS_ERROR_NOT_IMPLEMENTED;
if (mPump)
mPump->Suspend();
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
nsFingerChannel::Resume(void)
nsFingerChannel::Resume()
{
NS_NOTREACHED("nsFingerChannel::Resume");
return NS_ERROR_NOT_IMPLEMENTED;
if (mPump)
mPump->Resume();
return NS_ERROR_UNEXPECTED;
}
////////////////////////////////////////////////////////////////////////////////
@ -165,7 +162,7 @@ nsFingerChannel::Resume(void)
NS_IMETHODIMP
nsFingerChannel::GetOriginalURI(nsIURI* *aURI)
{
*aURI = mOriginalURI ? mOriginalURI : mUrl;
*aURI = mOriginalURI ? mOriginalURI : mURI;
NS_ADDREF(*aURI);
return NS_OK;
}
@ -180,7 +177,7 @@ nsFingerChannel::SetOriginalURI(nsIURI* aURI)
NS_IMETHODIMP
nsFingerChannel::GetURI(nsIURI* *aURI)
{
*aURI = mUrl;
*aURI = mURI;
NS_IF_ADDREF(*aURI);
return NS_OK;
}
@ -188,24 +185,8 @@ nsFingerChannel::GetURI(nsIURI* *aURI)
NS_IMETHODIMP
nsFingerChannel::Open(nsIInputStream **_retval)
{
nsresult rv = NS_OK;
rv = NS_CheckPortSafety(mPort, "finger");
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsISocketTransportService> socketService =
do_GetService(kSocketTransportServiceCID, &rv);
if (NS_FAILED(rv)) return rv;
rv = socketService->CreateTransport(mHost.get(), mPort, mProxyInfo, BUFFER_SEG_SIZE,
BUFFER_MAX_SIZE, getter_AddRefs(mTransport));
if (NS_FAILED(rv)) return rv;
mTransport->SetNotificationCallbacks(mCallbacks,
(mLoadFlags & LOAD_BACKGROUND));
return mTransport->OpenInputStream(0, PRUint32(-1), 0, _retval);
NS_NOTREACHED("nsFingerChannel::Open");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
@ -214,24 +195,77 @@ nsFingerChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *ctxt)
nsresult rv = NS_OK;
rv = NS_CheckPortSafety(mPort, "finger");
if (NS_FAILED(rv))
return rv;
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsISocketTransportService> socketService =
nsCOMPtr<nsIEventQueue> eventQ;
rv = NS_GetCurrentEventQ(getter_AddRefs(eventQ));
if (NS_FAILED(rv)) return rv;
//
// create transport
//
nsCOMPtr<nsISocketTransportService> sts =
do_GetService(kSocketTransportServiceCID, &rv);
if (NS_FAILED(rv)) return rv;
rv = socketService->CreateTransport(mHost.get(), mPort, mProxyInfo, BUFFER_SEG_SIZE,
BUFFER_MAX_SIZE, getter_AddRefs(mTransport));
rv = sts->CreateTransport(nsnull, 0, mHost, mPort, mProxyInfo,
getter_AddRefs(mTransport));
if (NS_FAILED(rv)) return rv;
mTransport->SetNotificationCallbacks(mCallbacks,
(mLoadFlags & LOAD_BACKGROUND));
// not fatal if these fail
mTransport->SetSecurityCallbacks(mCallbacks);
mTransport->SetEventSink(this, eventQ);
rv = WriteRequest(mTransport);
if (NS_FAILED(rv)) return rv;
//
// create TXT to HTML stream converter
//
nsCOMPtr<nsIStreamConverterService> scs =
do_GetService(kStreamConverterServiceCID, &rv);
if (NS_FAILED(rv)) return rv;
NS_NAMED_LITERAL_STRING(fromStr, "text/plain");
NS_NAMED_LITERAL_STRING(toStr, "text/html");
nsCOMPtr<nsIStreamListener> convListener;
rv = scs->AsyncConvertData(fromStr.get(), toStr.get(), this, nsnull,
getter_AddRefs(convListener));
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsITXTToHTMLConv> conv = do_QueryInterface(convListener);
if (conv) {
nsCAutoString userHost;
rv = mURI->GetPath(userHost);
nsAutoString title;
title = NS_LITERAL_STRING("Finger information for ")
+ NS_ConvertUTF8toUCS2(userHost);
conv->SetTitle(title.get());
conv->PreFormatHTML(PR_TRUE);
}
//
// open input stream, and create input stream pump...
//
nsCOMPtr<nsIInputStream> sockIn;
rv = mTransport->OpenInputStream(0, 0, 0, getter_AddRefs(sockIn));
if (NS_FAILED(rv)) return rv;
rv = NS_NewInputStreamPump(getter_AddRefs(mPump), sockIn);
if (NS_FAILED(rv)) return rv;
rv = mPump->AsyncRead(convListener, nsnull);
if (NS_FAILED(rv)) return rv;
if (mLoadGroup)
mLoadGroup->AddRequest(this, nsnull);
mListener = aListener;
mResponseContext = ctxt;
return SendRequest(mTransport);
mListenerContext = ctxt;
return NS_OK;
}
NS_IMETHODIMP
@ -248,49 +282,46 @@ nsFingerChannel::SetLoadFlags(PRUint32 aLoadFlags)
return NS_OK;
}
#define FINGER_TYPE TEXT_HTML
NS_IMETHODIMP
nsFingerChannel::GetContentType(nsACString &aContentType)
{
aContentType = NS_LITERAL_CSTRING(FINGER_TYPE);
aContentType = mContentType;
return NS_OK;
}
NS_IMETHODIMP
nsFingerChannel::SetContentType(const nsACString &aContentType)
{
//It doesn't make sense to set the content-type on this type
// of channel...
return NS_ERROR_FAILURE;
mContentType = aContentType;
return NS_OK;
}
NS_IMETHODIMP
nsFingerChannel::GetContentCharset(nsACString &aContentCharset)
{
aContentCharset.Truncate();
aContentCharset = mContentCharset;
return NS_OK;
}
NS_IMETHODIMP
nsFingerChannel::SetContentCharset(const nsACString &aContentCharset)
{
NS_NOTREACHED("nsFingerChannel::SetContentCharset");
return NS_ERROR_NOT_IMPLEMENTED;
mContentCharset = aContentCharset;
return NS_OK;
}
NS_IMETHODIMP
nsFingerChannel::GetContentLength(PRInt32 *aContentLength)
{
*aContentLength = mContentLength;
*aContentLength = -1;
return NS_OK;
}
NS_IMETHODIMP
nsFingerChannel::SetContentLength(PRInt32 aContentLength)
{
NS_NOTREACHED("nsFingerChannel::SetContentLength");
return NS_ERROR_NOT_IMPLEMENTED;
// silently ignore this...
return NS_OK;
}
NS_IMETHODIMP
@ -335,117 +366,96 @@ NS_IMETHODIMP
nsFingerChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aNotificationCallbacks)
{
mCallbacks = aNotificationCallbacks;
mProgressSink = do_GetInterface(mCallbacks);
return NS_OK;
}
NS_IMETHODIMP
nsFingerChannel::GetSecurityInfo(nsISupports * *aSecurityInfo)
nsFingerChannel::GetSecurityInfo(nsISupports **aSecurityInfo)
{
if (mTransport)
return mTransport->GetSecurityInfo(aSecurityInfo);
*aSecurityInfo = nsnull;
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsIRequestObserver methods
NS_IMETHODIMP
nsFingerChannel::OnStartRequest(nsIRequest *aRequest, nsISupports *aContext) {
if (!mActAsObserver) {
// acting as a listener
return mListener->OnStartRequest(this, mResponseContext);
} else {
// we don't want to pass our AsyncWrite's OnStart through
// we just ignore this
return NS_OK;
}
}
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsFingerChannel::OnStopRequest(nsIRequest *aRequest, nsISupports* aContext,
nsresult aStatus)
nsFingerChannel::OnStartRequest(nsIRequest *req, nsISupports *ctx)
{
nsresult rv = NS_OK;
if (NS_FAILED(aStatus) || !mActAsObserver) {
if (mLoadGroup) {
rv = mLoadGroup->RemoveRequest(this, nsnull, aStatus);
if (NS_FAILED(rv)) return rv;
}
rv = mListener->OnStopRequest(this, mResponseContext, aStatus);
mTransport = 0;
return rv;
} else {
// at this point we know the request has been sent.
// we're no longer acting as an observer.
mActAsObserver = PR_FALSE;
nsCOMPtr<nsIStreamListener> converterListener;
nsCOMPtr<nsIStreamConverterService> StreamConvService =
do_GetService(kStreamConverterServiceCID, &rv);
if (NS_FAILED(rv)) return rv;
nsAutoString fromStr(NS_LITERAL_STRING("text/plain"));
nsAutoString toStr(NS_LITERAL_STRING("text/html"));
rv = StreamConvService->AsyncConvertData(fromStr.get(),
toStr.get(), this, mResponseContext,
getter_AddRefs(converterListener));
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsITXTToHTMLConv> converter(do_QueryInterface(converterListener));
if (converter) {
nsAutoString title(NS_LITERAL_STRING("Finger information for "));
nsCAutoString userHost;
rv = mUrl->GetPath(userHost);
title.Append(NS_ConvertUTF8toUCS2(userHost));
converter->SetTitle(title.get());
converter->PreFormatHTML(PR_TRUE);
}
return mTransport->AsyncRead(converterListener, mResponseContext, 0, PRUint32(-1), 0,
getter_AddRefs(mTransportRequest));
}
return mListener->OnStartRequest(this, mListenerContext);
}
// nsIStreamListener method
NS_IMETHODIMP
nsFingerChannel::OnDataAvailable(nsIRequest *aRequest, nsISupports* aContext,
nsIInputStream *aInputStream, PRUint32 aSourceOffset,
PRUint32 aLength) {
mContentLength = aLength;
return mListener->OnDataAvailable(this, mResponseContext, aInputStream, aSourceOffset, aLength);
nsFingerChannel::OnStopRequest(nsIRequest *req, nsISupports *ctx, nsresult status)
{
if (NS_SUCCEEDED(mStatus))
mStatus = status;
mListener->OnStopRequest(this, mListenerContext, mStatus);
mListener = 0;
mListenerContext = 0;
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nsnull, mStatus);
mPump = 0;
mTransport = 0;
return NS_OK;
}
NS_IMETHODIMP
nsFingerChannel::OnDataAvailable(nsIRequest *req, nsISupports *ctx,
nsIInputStream *stream, PRUint32 offset,
PRUint32 count)
{
return mListener->OnDataAvailable(this, mListenerContext, stream, offset, count);
}
//-----------------------------------------------------------------------------
// nsITransportEventSink methods
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsFingerChannel::OnTransportStatus(nsITransport *trans, nsresult status,
PRUint32 progress, PRUint32 progressMax)
{
// suppress status notification if channel is no longer pending!
if (mProgressSink && mPump && !(mLoadFlags & LOAD_BACKGROUND)) {
NS_ConvertUTF8toUCS2 host(mHost);
mProgressSink->OnStatus(this, nsnull, status, host.get());
if (status == nsISocketTransport::STATUS_RECEIVING_FROM ||
status == nsISocketTransport::STATUS_SENDING_TO) {
mProgressSink->OnProgress(this, nsnull, progress, progressMax);
}
}
return NS_OK;
}
//-----------------------------------------------------------------------------
nsresult
nsFingerChannel::SendRequest(nsITransport* aTransport) {
// The text to send should already be in mUser
nsFingerChannel::WriteRequest(nsITransport *trans)
{
// The text to send should already be in mUser
nsresult rv;
nsresult rv = NS_OK;
nsCOMPtr<nsISupports> result;
nsCOMPtr<nsIInputStream> charstream;
nsCString requestBuffer(mUser);
nsCAutoString requestBuf;
requestBuf = mUser + NS_LITERAL_CSTRING("\r\n");
if (mLoadGroup) {
mLoadGroup->AddRequest(this, nsnull);
}
nsCOMPtr<nsIOutputStream> stream;
rv = trans->OpenOutputStream(0, requestBuf.Length(), 1, getter_AddRefs(stream));
if (NS_FAILED(rv)) return rv;
requestBuffer.Append(CRLF);
PRUint32 n;
rv = stream->Write(requestBuf.get(), requestBuf.Length(), &n);
if (NS_FAILED(rv)) return rv;
mRequest.Assign(requestBuffer);
rv = NS_NewCharInputStream(getter_AddRefs(result), mRequest);
if (NS_FAILED(rv)) return rv;
charstream = do_QueryInterface(result, &rv);
if (NS_FAILED(rv)) return rv;
rv = NS_AsyncWriteFromStream(getter_AddRefs(mTransportRequest),
aTransport, charstream,
0, requestBuffer.Length(), 0,
this, nsnull);
return rv;
NS_ENSURE_TRUE(n == requestBuf.Length(), NS_ERROR_UNEXPECTED);
return NS_OK;
}

72
extensions/finger/nsFingerChannel.h
Просмотреть файл

@ -17,75 +17,73 @@
* All Rights Reserved.
*
* Contributor(s):
* Brian Ryner <bryner@uiuc.edu>
* Brian Ryner <bryner@uiuc.edu>
* Darin Fisher <darin@netscape.com>
*/
#ifndef nsFingerChannel_h___
#define nsFingerChannel_h___
#ifndef nsFingerChannel_h__
#define nsFingerChannel_h__
#include "nsFingerHandler.h"
#include "nsString.h"
#include "nsCOMPtr.h"
#include "nsILoadGroup.h"
#include "nsIInputStream.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsCOMPtr.h"
#include "nsXPIDLString.h"
#include "nsIProgressEventSink.h"
#include "nsIInputStreamPump.h"
#include "nsIChannel.h"
#include "nsIURI.h"
#include "nsFingerHandler.h"
#include "nsIStreamListener.h"
#include "nsITransport.h"
#include "nsISocketTransport.h"
#include "nsIProxyInfo.h"
class nsFingerChannel
: public nsIChannel,
public nsIStreamListener {
//-----------------------------------------------------------------------------
class nsFingerChannel : public nsIChannel
, public nsIStreamListener
, public nsITransportEventSink
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIREQUEST
NS_DECL_NSICHANNEL
NS_DECL_NSISTREAMLISTENER
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSITRANSPORTEVENTSINK
// nsFingerChannel methods:
nsFingerChannel();
virtual ~nsFingerChannel();
// Define a Create method to be used with a factory:
static NS_METHOD
Create(nsISupports* aOuter, const nsIID& aIID, void* *aResult);
nsresult Init(nsIURI* uri, nsIProxyInfo* proxyInfo);
nsresult Init(nsIURI *uri, nsIProxyInfo *proxyInfo);
protected:
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsresult WriteRequest(nsITransport *transport);
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsIURI> mOriginalURI;
nsCOMPtr<nsIURI> mUrl;
nsCOMPtr<nsIStreamListener> mListener;
PRUint32 mLoadFlags;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCString mContentType;
PRInt32 mContentLength;
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsIProgressEventSink> mProgressSink;
nsCOMPtr<nsISupports> mOwner;
PRUint32 mBufferSegmentSize;
PRUint32 mBufferMaxSize;
PRBool mActAsObserver;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsIStreamListener> mListener;
nsCOMPtr<nsISupports> mListenerContext;
nsCString mContentType;
nsCString mContentCharset;
PRUint32 mLoadFlags;
nsresult mStatus;
nsCOMPtr<nsIInputStreamPump> mPump;
nsCOMPtr<nsISocketTransport> mTransport;
nsCOMPtr<nsIProxyInfo> mProxyInfo;
PRInt32 mPort;
nsCString mHost;
nsCString mUser;
nsXPIDLCString mRequest;
nsCOMPtr<nsISupports> mResponseContext;
nsCOMPtr<nsITransport> mTransport;
nsCOMPtr<nsIRequest> mTransportRequest;
nsCOMPtr<nsIProxyInfo> mProxyInfo;
nsresult mStatus;
protected:
nsresult SendRequest(nsITransport* aTransport);
};
#endif /* nsFingerChannel_h___ */
#endif // !nsFingerChannel_h__

13
extensions/finger/nsFingerHandler.cpp
Просмотреть файл

@ -113,17 +113,18 @@ nsFingerHandler::NewProxiedChannel(nsIURI* url, nsIProxyInfo* proxyInfo,
{
nsresult rv;
nsFingerChannel* channel;
rv = nsFingerChannel::Create(nsnull, NS_GET_IID(nsIChannel), (void**)&channel);
if (NS_FAILED(rv)) return rv;
nsFingerChannel *chan = new nsFingerChannel();
if (!chan)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(chan);
rv = channel->Init(url, proxyInfo);
rv = chan->Init(url, proxyInfo);
if (NS_FAILED(rv)) {
NS_RELEASE(channel);
NS_RELEASE(chan);
return rv;
}
*result = channel;
*result = chan;
return NS_OK;
}

88
extensions/irc/js/lib/connection-xpcom.js
Просмотреть файл

@ -93,29 +93,54 @@ function bc_connect(host, port, bind, tcp_flag, observer)
var uri = ios.newURI(spec,null,null);
var info = pps.examineForProxy(uri);
this._transport = this._sockService.createTransport (host, port, info,
0, 0);
if (!this._transport)
throw ("Error creating transport.");
if (jsenv.HAS_STREAM_PROVIDER)
{
this._transport = this._sockService.createTransport (host, port, info,
0, 0);
if (!this._transport)
throw ("Error creating transport.");
if (jsenv.HAS_NSPR_EVENTQ)
{ /* we've got an event queue, so start up an async write */
this._streamProvider = new StreamProvider (observer);
this._write_req =
this._transport.asyncWrite (this._streamProvider, this,
0, -1, 0);
if (jsenv.HAS_NSPR_EVENTQ)
{ /* we've got an event queue, so start up an async write */
this._streamProvider = new StreamProvider (observer);
this._write_req =
this._transport.asyncWrite (this._streamProvider, this,
0, -1, 0);
}
else
{ /* no nspr event queues in this environment, we can't use async calls,
* so set up the streams. */
this._outputStream = this._transport.openOutputStream(0, -1, 0);
if (!this._outputStream)
throw "Error getting output stream.";
this._inputStream =
toScriptableInputStream(this._transport.openInputStream (0, -1, 0));
if (!this._inputStream)
throw "Error getting input stream.";
}
}
else
{ /* no nspr event queues in this environment, we can't use async calls,
* so set up the streams. */
this._outputStream = this._transport.openOutputStream(0, -1, 0);
{
/* use new necko interfaces */
this._transport = this._sockService.createTransport(null, 0, host, port, info);
if (!this._transport)
throw ("Error creating transport.");
/* if we don't have an event queue, then all i/o must be blocking */
var openFlags;
if (jsenv.HAS_NSPR_EVENTQ)
openFlags = 0;
else
openFlags = Components.interfaces.nsITransport.OPEN_BLOCKING;
/* no limit on the output stream buffer */
this._outputStream = this._transport.openOutputStream(openFlags, 4096, -1);
if (!this._outputStream)
throw "Error getting output stream.";
this._inputStream =
toScriptableInputStream(this._transport.openInputStream (0, -1, 0));
this._inputStream = this._transport.openInputStream(openFlags, 0, 0);
if (!this._inputStream)
throw "Error getting input stream.";
}
}
this.connectDate = new Date();
this.isConnected = true;
@ -129,6 +154,8 @@ function bc_disconnect()
{
if ("_inputStream" in this && this._inputStream)
this._inputStream.close();
if ("_outputStream" in this && this._outputStream)
this._outputStream.close();
/*
this._streamProvider.close();
if (this._streamProvider.isBlocked)
@ -142,7 +169,7 @@ function bc_senddata(str)
if (!this.isConnected)
throw "Not Connected.";
if (jsenv.HAS_NSPR_EVENTQ)
if (jsenv.HAS_NSPR_EVENTQ && jsenv.HAS_STREAM_PROVIDER)
this.asyncWrite (str);
else
this.sendDataNow (str);
@ -158,7 +185,7 @@ function bc_readdata(timeout, count)
try
{
rv = this._inputStream.read (count);
rv = this._scriptableInputStream.read (count);
}
catch (ex)
{
@ -173,7 +200,15 @@ function bc_readdata(timeout, count)
CBSConnection.prototype.startAsyncRead =
function bc_saread (observer)
{
this._transport.asyncRead (new StreamListener (observer), this, 0, -1, 0);
if (jsenv.HAS_STREAM_PROVIDER)
this._transport.asyncRead (new StreamListener (observer), this, 0, -1, 0);
else
{
var pump = Components.classes["@mozilla.org/network/input-stream-pump;1"].
createInstance(Components.interfaces.nsIInputStreamPump);
pump.init(this._inputStream, -1, -1, 0, 0, false);
pump.asyncRead(new StreamListener(observer), this);
}
}
CBSConnection.prototype.asyncWrite =
@ -190,7 +225,10 @@ function bc_awrite (str)
CBSConnection.prototype.hasPendingWrite =
function bc_haspwrite ()
{
return (this._streamProvider.pendingData != "");
if (jsenv.HAS_STREAM_PROVIDER)
return (this._streamProvider.pendingData != "");
else
return false; /* data already pushed to necko */
}
CBSConnection.prototype.sendDataNow =
@ -223,10 +261,14 @@ if (!jsenv.HAS_NSPR_EVENTQ)
CBSConnection.prototype.startAsyncRead = _notimpl;
CBSConnection.prototype.asyncWrite = _notimpl;
}
else
else if (jsenv.HAS_STREAM_PROVIDER)
{
CBSConnection.prototype.sendDataNow = _notimpl;
}
else
{
CBSConnection.prototype.asyncWrite = _notimpl;
}
delete _notimpl;
@ -314,8 +356,8 @@ function sl_dataavail (request, ctxt, inStr, sourceOffset, count)
"StreamListener.onDataAvailable ***");
return;
}
if (!ctxt._inputStream)
ctxt._inputStream = toScriptableInputStream (inStr);
if (!ctxt._scriptableInputStream)
ctxt._scriptableInputStream = toScriptableInputStream (inStr);
if (this._observer)
this._observer.onStreamDataAvailable(request, inStr, sourceOffset,

2
extensions/pref/autoconfig/src/nsReadConfig.cpp
Просмотреть файл

@ -44,7 +44,6 @@
#include "nsIAutoConfig.h"
#include "nsIComponentManager.h"
#include "nsIFile.h"
#include "nsIFileStreams.h"
#include "nsIObserverService.h"
#include "nsIPrefBranch.h"
#include "nsIPrefService.h"
@ -52,6 +51,7 @@
#include "nsIServiceManager.h"
#include "nsIStringBundle.h"
#include "nsXPIDLString.h"
#include "nsNetUtil.h"
#include "prmem.h"
#include "nsString.h"
#include "nsCRT.h"

2
extensions/xmlterm/base/mozXMLTermSession.cpp
Просмотреть файл

@ -34,7 +34,7 @@
#include "nsIDocumentViewer.h"
#include "nsILocalFile.h"
#include "nsIFileStreams.h"
#include "nsNetUtil.h"
#include "nsITextContent.h"

4
extensions/xmlterm/base/mozXMLTermStream.cpp
Просмотреть файл

@ -204,13 +204,11 @@ NS_IMETHODIMP mozXMLTermStream::Open(nsIDOMWindowInternal* aDOMWindow,
return result;
// Create an input stream channel
PRInt32 contentLength = 1024;
result = NS_NewInputStreamChannel(getter_AddRefs(mChannel),
uri,
inputStream,
nsDependentCString(contentType),
NS_LITERAL_CSTRING(""),
contentLength);
NS_LITERAL_CSTRING(""));
if (NS_FAILED(result))
return result;

4
mailnews/addrbook/src/nsAddbookProtocolHandler.cpp
Просмотреть файл

@ -136,9 +136,7 @@ nsAddbookProtocolHandler::GenerateXMLOutputChannel( nsString &aOutput,
NS_ENSURE_SUCCESS(rv, rv);
rv = NS_NewInputStreamChannel(&channel, aURI, inStr,
NS_LITERAL_CSTRING("text/xml"),
NS_LITERAL_CSTRING(""),
utf8String.Length());
NS_LITERAL_CSTRING("text/xml"));
NS_ENSURE_SUCCESS(rv, rv);
*_retval = channel;

2
mailnews/addrbook/src/nsAddressBook.cpp
Просмотреть файл

@ -45,7 +45,7 @@
#include "nsIAddrBookSession.h"
#include "nsAddrDatabase.h"
#include "nsIOutputStream.h"
#include "nsIFileStreams.h"
#include "nsNetUtil.h"
#include "msgCore.h"
#include "nsIImportService.h"
#include "nsIStringBundle.h"

2
mailnews/base/public/nsIMsgFolder.idl
Просмотреть файл

@ -376,7 +376,7 @@ const nsMsgBiffState nsMsgBiffState_Unknown = 2; // We dunno whether there is ne
boolean shouldStoreMsgOffline(in nsMsgKey msgKey);
boolean hasMsgOffline(in nsMsgKey msgKey);
nsITransport getOfflineFileTransport(in nsMsgKey msgKey, out PRUint32 offset, out PRUint32 size);
nsIInputStream getOfflineFileStream(in nsMsgKey msgKey, out PRUint32 offset, out PRUint32 size);
readonly attribute nsIOutputStream offlineStoreOutputStream;
readonly attribute nsIInputStream offlineStoreInputStream;
void DownloadMessagesForOffline(in nsISupportsArray messages, in nsIMsgWindow window);

2
mailnews/base/search/src/nsMsgFilterList.cpp
Просмотреть файл

@ -53,8 +53,8 @@
#include "nsIImportService.h"
#include "nsMsgBaseCID.h"
#include "nsIMsgFilterService.h"
#include "nsIFileStreams.h"
#include "nsISupportsObsolete.h"
#include "nsNetUtil.h"
// unicode "%s" format string
static const PRUnichar unicodeFormatter[] = {

3
mailnews/base/src/nsMessenger.cpp
Просмотреть файл

@ -969,8 +969,7 @@ nsMessenger::SaveAs(const char* url, PRBool asFile, nsIMsgIdentity* identity, ns
aURL,
nsnull, // inputStream
NS_LITERAL_CSTRING(""), // contentType
NS_LITERAL_CSTRING(""), // contentCharset
-1); // contentLength
NS_LITERAL_CSTRING("")); // contentCharset
if (NS_FAILED(rv)) goto done;
saveListener->m_outputFormat.AssignWithConversion(saveAsFileType == 1 ? TEXT_HTML : TEXT_PLAIN);

2
mailnews/base/src/nsSpamSettings.cpp
Просмотреть файл

@ -42,9 +42,9 @@
#include "nsILocalFile.h"
#include "plstr.h"
#include "prmem.h"
#include "nsIFileStreams.h"
#include "nsIMsgHdr.h"
#include "nsEscape.h"
#include "nsNetUtil.h"
#include "nsIMsgFolder.h"
#include "nsMsgUtils.h"
#include "nsMsgFolderFlags.h"

53
mailnews/base/util/nsMsgDBFolder.cpp
Просмотреть файл

@ -42,7 +42,7 @@
#include "nsMsgFolderFlags.h"
#include "nsIPrefBranch.h"
#include "nsIPrefService.h"
#include "nsIFileChannel.h"
#include "nsNetUtil.h"
#include "nsIMsgFolderCache.h"
#include "nsIMsgFolderCacheElement.h"
#include "nsMsgBaseCID.h"
@ -53,7 +53,6 @@
#include "nsIFileStream.h"
#include "nsIChannel.h"
#include "nsITransport.h"
#include "nsIFileTransportService.h"
#include "nsIMsgFolderCompactor.h"
#include "nsIDocShell.h"
#include "nsIMsgWindow.h"
@ -520,50 +519,34 @@ NS_IMETHODIMP nsMsgDBFolder::GetOfflineStoreInputStream(nsIInputStream **stream)
return rv;
}
NS_IMETHODIMP nsMsgDBFolder::GetOfflineFileTransport(nsMsgKey msgKey, PRUint32 *offset, PRUint32 *size, nsITransport **aFileChannel)
NS_IMETHODIMP nsMsgDBFolder::GetOfflineFileStream(nsMsgKey msgKey, PRUint32 *offset, PRUint32 *size, nsIInputStream **aFileStream)
{
NS_ENSURE_ARG(aFileChannel);
NS_ENSURE_ARG(aFileStream);
*offset = *size = 0;
nsresult rv;
rv = nsComponentManager::CreateInstance(NS_LOCALFILECHANNEL_CONTRACTID, nsnull,
NS_GET_IID(nsIFileChannel), (void **) aFileChannel);
if (*aFileChannel)
nsXPIDLCString nativePath;
mPath->GetNativePath(getter_Copies(nativePath));
nsCOMPtr <nsILocalFile> localStore;
rv = NS_NewNativeLocalFile(nativePath, PR_TRUE, getter_AddRefs(localStore));
if (NS_SUCCEEDED(rv) && localStore)
{
nsXPIDLCString nativePath;
mPath->GetNativePath(getter_Copies(nativePath));
rv = NS_NewLocalFileInputStream(aFileStream, localStore);
nsCOMPtr <nsILocalFile> localStore;
rv = NS_NewNativeLocalFile(nativePath, PR_TRUE, getter_AddRefs(localStore));
if (NS_SUCCEEDED(rv) && localStore)
if (NS_SUCCEEDED(rv))
{
NS_DEFINE_CID(kFileTransportServiceCID, NS_FILETRANSPORTSERVICE_CID);
nsCOMPtr<nsIFileTransportService> fts =
do_GetService(kFileTransportServiceCID, &rv);
if (NS_FAILED(rv))
return rv;
rv = fts->CreateTransport(localStore,
PR_RDWR | PR_CREATE_FILE,
0664,
PR_TRUE,
aFileChannel);
if (NS_SUCCEEDED(rv))
nsresult rv = GetDatabase(nsnull);
NS_ENSURE_SUCCESS(rv, NS_OK);
nsCOMPtr<nsIMsgDBHdr> hdr;
rv = mDatabase->GetMsgHdrForKey(msgKey, getter_AddRefs(hdr));
if (hdr && NS_SUCCEEDED(rv))
{
nsresult rv = GetDatabase(nsnull);
NS_ENSURE_SUCCESS(rv, NS_OK);
nsCOMPtr<nsIMsgDBHdr> hdr;
rv = mDatabase->GetMsgHdrForKey(msgKey, getter_AddRefs(hdr));
if (hdr && NS_SUCCEEDED(rv))
{
hdr->GetMessageOffset(offset);
hdr->GetOfflineMessageSize(size);
}
hdr->GetMessageOffset(offset);
hdr->GetOfflineMessageSize(size);
}
}
}

2
mailnews/base/util/nsMsgDBFolder.h
Просмотреть файл

@ -105,7 +105,7 @@ public:
NS_IMETHOD GetSupportsOffline(PRBool *aSupportsOffline);
NS_IMETHOD ShouldStoreMsgOffline(nsMsgKey msgKey, PRBool *result);
NS_IMETHOD GetOfflineFileTransport(nsMsgKey msgKey, PRUint32 *offset, PRUint32 *size, nsITransport **_retval);
NS_IMETHOD GetOfflineFileStream(nsMsgKey msgKey, PRUint32 *offset, PRUint32 *size, nsIInputStream **_retval);
NS_IMETHOD HasMsgOffline(nsMsgKey msgKey, PRBool *result);
NS_IMETHOD DownloadMessagesForOffline(nsISupportsArray *messages, nsIMsgWindow *msgWindow);
NS_IMETHOD DownloadAllForOffline(nsIUrlListener *listener, nsIMsgWindow *msgWindow);

224
mailnews/base/util/nsMsgProtocol.cpp
Просмотреть файл

@ -39,7 +39,9 @@
#include "nsReadableUtils.h"
#include "nsMsgProtocol.h"
#include "nsIMsgMailNewsUrl.h"
#include "nsIStreamTransportService.h"
#include "nsISocketTransportService.h"
#include "nsISocketTransport.h"
#include "nsXPIDLString.h"
#include "nsSpecialSystemDirectory.h"
#include "nsILoadGroup.h"
@ -47,7 +49,6 @@
#include "nsNetUtil.h"
#include "nsIFileURL.h"
#include "nsFileStream.h"
#include "nsIFileTransportService.h"
#include "nsIDNSService.h"
#include "nsIMsgWindow.h"
#include "nsIMsgStatusFeedback.h"
@ -58,10 +59,11 @@
#include "nsIStringBundle.h"
#include "nsIProtocolProxyService.h"
#include "nsIProxyInfo.h"
#include "nsEventQueueUtils.h"
static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID);
static NS_DEFINE_CID(kStreamTransportServiceCID, NS_STREAMTRANSPORTSERVICE_CID);
static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
static NS_DEFINE_CID(kFileTransportServiceCID, NS_FILETRANSPORTSERVICE_CID);
NS_IMPL_THREADSAFE_ADDREF(nsMsgProtocol)
NS_IMPL_THREADSAFE_RELEASE(nsMsgProtocol)
@ -72,6 +74,7 @@ NS_INTERFACE_MAP_BEGIN(nsMsgProtocol)
NS_INTERFACE_MAP_ENTRY(nsIRequestObserver)
NS_INTERFACE_MAP_ENTRY(nsIChannel)
NS_INTERFACE_MAP_ENTRY(nsIRequest)
NS_INTERFACE_MAP_ENTRY(nsITransportEventSink)
NS_INTERFACE_MAP_END_THREADSAFE
static PRUnichar *GetStringByID(PRInt32 stringID);
@ -81,7 +84,6 @@ static PRUnichar *FormatStringWithHostNameByID(PRInt32 stringID, nsIMsgMailNewsU
nsMsgProtocol::nsMsgProtocol(nsIURI * aURL)
{
m_flags = 0;
m_startPosition = 0;
m_readCount = 0;
mLoadFlags = 0;
m_socketIsOpen = PR_FALSE;
@ -125,15 +127,24 @@ nsMsgProtocol::OpenNetworkSocketWithInfo(const char * aHostName,
// with socket connections we want to read as much data as arrives
m_readCount = -1;
m_startPosition = 0;
rv = socketService->CreateTransportOfType(connectionType, aHostName,
aGetPort, aProxyInfo, 0, 0,
getter_AddRefs(m_transport));
nsCOMPtr<nsISocketTransport> strans;
rv = socketService->CreateTransport(&connectionType, connectionType != nsnull,
nsDependentCString(aHostName),
aGetPort, aProxyInfo,
getter_AddRefs(strans));
if (NS_FAILED(rv)) return rv;
m_transport->SetNotificationCallbacks(callbacks, PR_FALSE);
strans->SetSecurityCallbacks(callbacks);
// creates cyclic reference!
nsCOMPtr<nsIEventQueue> eventQ;
NS_GetCurrentEventQ(getter_AddRefs(eventQ));
if (eventQ)
strans->SetEventSink(this, eventQ);
m_socketIsOpen = PR_FALSE;
m_transport = strans;
return SetupTransportState();
}
@ -220,37 +231,41 @@ nsresult nsMsgProtocol::OpenFileSocket(nsIURI * aURL, PRUint32 aStartPosition, P
// rid of this method completely.
nsresult rv = NS_OK;
m_startPosition = aStartPosition;
m_readCount = aReadCount;
nsCOMPtr <nsIFile> file;
rv = GetFileFromURL(aURL, getter_AddRefs(file));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIFileTransportService> fts =
do_GetService(kFileTransportServiceCID, &rv);
nsCOMPtr<nsIInputStream> stream;
rv = NS_NewLocalFileInputStream(getter_AddRefs(stream), file);
if (NS_FAILED(rv)) return rv;
//we are always using this file socket to read data from the mailbox.
rv = fts->CreateTransport(file, PR_RDONLY,
0664, PR_TRUE, getter_AddRefs(m_transport));
m_socketIsOpen = PR_FALSE;
// create input stream transport
nsCOMPtr<nsIStreamTransportService> sts =
do_GetService(kStreamTransportServiceCID, &rv);
if (NS_FAILED(rv)) return rv;
rv = sts->CreateInputTransport(stream, aStartPosition, aReadCount, PR_TRUE, getter_AddRefs(m_transport));
m_socketIsOpen = PR_FALSE;
return rv;
}
nsresult nsMsgProtocol::SetupTransportState()
{
nsresult rv = NS_OK;
if (!m_socketIsOpen && m_transport)
{
rv = m_transport->OpenOutputStream(0, PRUint32(-1), 0, getter_AddRefs(m_outputStream));
nsresult rv;
// open buffered, blocking output stream
rv = m_transport->OpenOutputStream(nsITransport::OPEN_BLOCKING, 0, 0, getter_AddRefs(m_outputStream));
if (NS_FAILED(rv)) return rv;
NS_ASSERTION(NS_SUCCEEDED(rv), "unable to create an output stream");
// we want to open the stream
} // if m_transport
return rv;
return NS_OK;
}
nsresult nsMsgProtocol::CloseSocket()
@ -258,15 +273,24 @@ nsresult nsMsgProtocol::CloseSocket()
nsresult rv = NS_OK;
// release all of our socket state
m_socketIsOpen = PR_FALSE;
m_inputStream = nsnull;
m_outputStream = nsnull;
if (m_transport)
m_transport->SetNotificationCallbacks(nsnull, PR_FALSE);
if (m_transport) {
nsCOMPtr<nsISocketTransport> strans = do_QueryInterface(m_transport);
if (strans) {
strans->SetSecurityCallbacks(nsnull);
strans->SetEventSink(nsnull, nsnull); // break cyclic reference!
}
}
// we need to call Cancel so that we remove the socket transport from the mActiveTransportList. see bug #30648
if (m_request) {
rv = m_request->Cancel(NS_BINDING_ABORTED);
}
m_request = 0;
m_transport = 0;
m_request = 0;
if (m_transport) {
m_transport->Close(NS_BINDING_ABORTED);
m_transport = 0;
}
return rv;
}
@ -434,8 +458,23 @@ nsresult nsMsgProtocol::LoadUrl(nsIURI * aURL, nsISupports * aConsumer)
nsCOMPtr<nsISupports> urlSupports = do_QueryInterface(aURL);
if (m_transport)
{
// don't open the input stream more than once
if (!m_inputStream)
{
// open buffered, asynchronous input stream
rv = m_transport->OpenInputStream(0, 0, 0, getter_AddRefs(m_inputStream));
if (NS_FAILED(rv)) return rv;
}
nsCOMPtr<nsIInputStreamPump> pump;
rv = NS_NewInputStreamPump(getter_AddRefs(pump),
m_inputStream, -1, m_readCount);
if (NS_FAILED(rv)) return rv;
m_request = pump; // keep a reference to the pump so we can cancel it
// put us in a state where we are always notified of incoming data
rv = m_transport->AsyncRead(this, urlSupports, m_startPosition, m_readCount, 0, getter_AddRefs(m_request));
rv = pump->AsyncRead(this, urlSupports);
NS_ASSERTION(NS_SUCCEEDED(rv), "AsyncRead failed");
m_socketIsOpen = PR_TRUE; // mark the channel as open
}
@ -626,6 +665,24 @@ nsMsgProtocol::SetNotificationCallbacks(nsIInterfaceRequestor* aNotificationCall
return NS_OK;
}
NS_IMETHODIMP
nsMsgProtocol::OnTransportStatus(nsITransport *transport, nsresult status,
PRUint32 progress, PRUint32 progressMax)
{
if (mProgressEventSink && !(mLoadFlags & LOAD_BACKGROUND)) {
nsCAutoString host;
if (m_url)
m_url->GetHost(host);
mProgressEventSink->OnStatus(this, nsnull, status, NS_ConvertUTF8toUCS2(host).get());
if (status == nsISocketTransport::STATUS_RECEIVING_FROM ||
status == nsISocketTransport::STATUS_SENDING_TO ||
status == nsITransport::STATUS_READING ||
status == nsITransport::STATUS_WRITING)
mProgressEventSink->OnProgress(this, nsnull, progress, progressMax);
}
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// From nsIRequest
////////////////////////////////////////////////////////////////////////////////
@ -656,14 +713,20 @@ NS_IMETHODIMP nsMsgProtocol::Cancel(nsresult status)
NS_IMETHODIMP nsMsgProtocol::Suspend()
{
NS_NOTREACHED("Suspend");
return NS_ERROR_NOT_IMPLEMENTED;
if (m_request)
return m_request->Suspend();
NS_WARNING("no request to suspend");
return NS_ERROR_NOT_AVAILABLE;
}
NS_IMETHODIMP nsMsgProtocol::Resume()
{
NS_NOTREACHED("Resume");
return NS_ERROR_NOT_IMPLEMENTED;
if (m_request)
return m_request->Resume();
NS_WARNING("no request to resume");
return NS_ERROR_NOT_AVAILABLE;
}
nsresult nsMsgProtocol::PostMessage(nsIURI* url, nsIFileSpec *fileSpec)
@ -780,7 +843,7 @@ nsresult nsMsgProtocol::PostMessage(nsIURI* url, nsIFileSpec *fileSpec)
// nsMsgAsyncWriteProtocol subclass and related helper classes
/////////////////////////////////////////////////////////////////////
class nsMsgProtocolStreamProvider : public nsIStreamProvider
class nsMsgProtocolStreamProvider : public nsIOutputStreamNotify
{
public:
NS_DECL_ISUPPORTS
@ -788,20 +851,16 @@ public:
nsMsgProtocolStreamProvider() { }
virtual ~nsMsgProtocolStreamProvider() {}
void Init(nsMsgAsyncWriteProtocol *aProtInstance, nsIInputStream *aInputStream) { mMsgProtocol = aProtInstance; mInStream = aInputStream;}
void Init(nsMsgAsyncWriteProtocol *aProtInstance, nsIInputStream *aInputStream)
{
mMsgProtocol = aProtInstance;
mInStream = aInputStream;
}
//
// nsIRequestObserver implementation ...
// nsIOutputStreamNotify implementation ...
//
NS_IMETHODIMP OnStartRequest(nsIRequest *chan, nsISupports *ctxt) { return NS_OK; }
NS_IMETHODIMP OnStopRequest(nsIRequest *chan, nsISupports *ctxt, nsresult status) { return NS_OK; }
//
// nsIStreamProvider implementation ...
//
NS_IMETHODIMP OnDataWritable(nsIRequest *aChannel, nsISupports *aContext,
nsIOutputStream *aOutStream,
PRUint32 aOffset, PRUint32 aCount)
NS_IMETHODIMP OnOutputStreamReady(nsIAsyncOutputStream *aOutStream)
{
NS_ASSERTION(mInStream, "not initialized");
@ -817,30 +876,37 @@ public:
if (avail == 0)
{
// ok, stop writing...
mMsgProtocol->mSuspendedWrite = PR_TRUE;
return NS_BASE_STREAM_WOULD_BLOCK;
return NS_OK;
}
PRUint32 bytesWritten;
rv = aOutStream->WriteFrom(mInStream, PR_MIN(avail, aCount), &bytesWritten);
rv = aOutStream->WriteFrom(mInStream, PR_MIN(avail, 4096), &bytesWritten);
// if were full at the time, the input stream may be backed up and we need to read any remains from the last ODA call
// before we'll get more ODA calls
if (mMsgProtocol->mSuspendedRead)
mMsgProtocol->UnblockPostReader();
mMsgProtocol->UpdateProgress(bytesWritten);
return rv;
// try to write again...
if (NS_SUCCEEDED(rv))
rv = aOutStream->AsyncWait(this, 0, mMsgProtocol->mProviderEventQ);
NS_ASSERTION(NS_SUCCEEDED(rv) || rv == NS_BINDING_ABORTED, "unexpected error writing stream");
return NS_OK;
}
protected:
nsMsgAsyncWriteProtocol * mMsgProtocol;
nsCOMPtr<nsIInputStream> mInStream;
nsCOMPtr<nsIInputStream> mInStream;
};
NS_IMPL_THREADSAFE_ISUPPORTS2(nsMsgProtocolStreamProvider,
nsIStreamProvider,
nsIRequestObserver)
// XXX this probably doesn't need to be threadsafe
NS_IMPL_THREADSAFE_ISUPPORTS1(nsMsgProtocolStreamProvider,
nsIOutputStreamNotify)
class nsMsgFilePostHelper : public nsIStreamListener
{
@ -874,18 +940,19 @@ nsresult nsMsgFilePostHelper::Init(nsIOutputStream * aOutStream, nsMsgAsyncWrite
mOutStream = aOutStream;
mProtInstance = aProtInstance; // mscott work out ref counting issue
nsCOMPtr<nsIFileTransportService> fts =
do_GetService(kFileTransportServiceCID, &rv);
nsCOMPtr<nsIInputStream> stream;
rv = NS_NewLocalFileInputStream(getter_AddRefs(stream), aFileToPost);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsITransport> transport;
rv = fts->CreateTransport(aFileToPost, PR_RDONLY, 0664, PR_TRUE, getter_AddRefs(transport));
if (transport)
{
rv = transport->AsyncRead(this, nsnull, 0, PRUint32(-1), 0, getter_AddRefs(mPostFileRequest));
}
return rv;
nsCOMPtr<nsIInputStreamPump> pump;
rv = NS_NewInputStreamPump(getter_AddRefs(pump), stream);
if (NS_FAILED(rv)) return rv;
rv = pump->AsyncRead(this, nsnull);
if (NS_FAILED(rv)) return rv;
mPostFileRequest = pump;
return NS_OK;
}
NS_IMETHODIMP nsMsgFilePostHelper::OnStartRequest(nsIRequest * aChannel, nsISupports *ctxt)
@ -923,7 +990,8 @@ NS_IMETHODIMP nsMsgFilePostHelper::OnDataAvailable(nsIRequest * /* aChannel */,
// data to write (i.e. the pipe went empty). So resume the channel to kick
// things off again.
mProtInstance->mSuspendedWrite = PR_FALSE;
mProtInstance->m_WriteRequest->Resume();
mProtInstance->mAsyncOutStream->AsyncWait(mProtInstance->mProvider, 0,
mProtInstance->mProviderEventQ);
}
return NS_OK;
@ -954,8 +1022,8 @@ NS_IMETHODIMP nsMsgAsyncWriteProtocol::Cancel(nsresult status)
if (m_request)
m_request->Cancel(status);
if (m_WriteRequest)
m_WriteRequest->Cancel(status);
if (mAsyncOutStream)
mAsyncOutStream->CloseEx(status);
return NS_OK;
}
@ -1188,15 +1256,25 @@ nsresult nsMsgAsyncWriteProtocol::SetupTransportState()
PR_TRUE,
PR_TRUE);
nsCOMPtr<nsIStreamProvider> provider;
rv = NS_GetCurrentEventQ(getter_AddRefs(mProviderEventQ));
if (NS_FAILED(rv)) return rv;
nsMsgProtocolStreamProvider *provider;
NS_NEWXPCOM(provider, nsMsgProtocolStreamProvider);
if (!provider) return NS_ERROR_OUT_OF_MEMORY;
NS_STATIC_CAST(nsMsgProtocolStreamProvider*,
NS_STATIC_CAST(nsIStreamProvider*, provider))->Init(this, mInStream);
provider->Init(this, mInStream);
mProvider = provider; // ADDREF
rv = m_transport->AsyncWrite(provider, nsnull, 0, 0, 0, getter_AddRefs(m_WriteRequest));
nsCOMPtr<nsIOutputStream> stream;
rv = m_transport->OpenOutputStream(0, 0, 0, getter_AddRefs(stream));
if (NS_FAILED(rv)) return rv;
mAsyncOutStream = do_QueryInterface(stream, &rv);
if (NS_FAILED(rv)) return rv;
// wait for the output stream to become writable
rv = mAsyncOutStream->AsyncWait(mProvider, 0, mProviderEventQ);
} // if m_transport
return rv;
@ -1207,9 +1285,8 @@ nsresult nsMsgAsyncWriteProtocol::CloseSocket()
nsresult rv = NS_OK;
nsMsgProtocol::CloseSocket();
// we need to call Cancel so that we remove the socket transport from the mActiveTransportList. see bug #30648
if (m_WriteRequest)
rv = m_WriteRequest->Cancel(NS_BINDING_ABORTED);
if (mAsyncOutStream)
mAsyncOutStream->CloseEx(NS_BINDING_ABORTED);
if (mFilePostHelper)
{
@ -1217,7 +1294,9 @@ nsresult nsMsgAsyncWriteProtocol::CloseSocket()
mFilePostHelper = nsnull;
}
m_WriteRequest = 0;
mAsyncOutStream = 0;
mProvider = 0;
mProviderEventQ = 0;
return rv;
}
@ -1238,7 +1317,8 @@ void nsMsgAsyncWriteProtocol::UpdateProgress(PRUint32 aNewBytes)
nsCOMPtr<nsIWebProgressListener> webProgressListener (do_QueryInterface(statusFeedback));
if (!webProgressListener) return;
webProgressListener->OnProgressChange(nsnull, m_WriteRequest, mNumBytesPosted, mFilePostSize, mNumBytesPosted, mFilePostSize);
// XXX not sure if m_request is correct here
webProgressListener->OnProgressChange(nsnull, m_request, mNumBytesPosted, mFilePostSize, mNumBytesPosted, mFilePostSize);
}
return;
@ -1258,7 +1338,7 @@ PRInt32 nsMsgAsyncWriteProtocol::SendData(nsIURI * aURL, const char * dataBuffer
// data to write (i.e. the pipe went empty). So resume the channel to kick
// things off again.
mSuspendedWrite = PR_FALSE;
m_WriteRequest->Resume();
mAsyncOutStream->AsyncWait(mProvider, 0, mProviderEventQ);
}
return NS_OK;
}
@ -1325,3 +1405,5 @@ PRUnichar *FormatStringWithHostNameByID(PRInt32 stringID, nsIMsgMailNewsUrl *msg
return (ptrv);
}
// vim: ts=2 sw=2

14
mailnews/base/util/nsMsgProtocol.h
Просмотреть файл

@ -48,9 +48,10 @@
#include "nsIFileSpec.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsIStreamProvider.h"
#include "nsIProgressEventSink.h"
#include "nsITransport.h"
#include "nsIAsyncOutputStream.h"
#include "nsIEventQueue.h"
#define UNKNOWN_ERROR 101
#define UNKNOWN_HOST_ERROR 102
@ -67,7 +68,9 @@ class nsIProxyInfo;
// it unifies the core networking code for the protocols. My hope is that
// this will make unification with Necko easier as we'll only have to change
// this class and not all of the mailnews protocols.
class NS_MSG_BASE nsMsgProtocol : public nsIStreamListener, public nsIChannel
class NS_MSG_BASE nsMsgProtocol : public nsIStreamListener
, public nsIChannel
, public nsITransportEventSink
{
public:
nsMsgProtocol(nsIURI * aURL);
@ -80,6 +83,7 @@ public:
NS_DECL_NSISTREAMLISTENER
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSITRANSPORTEVENTSINK
// LoadUrl -- A protocol typically overrides this function, sets up any local state for the url and
// then calls the base class which opens the socket if it needs opened. If the socket is
@ -139,6 +143,7 @@ protected:
// Ouput stream for writing commands to the socket
nsCOMPtr<nsIOutputStream> m_outputStream; // this will be obtained from the transport interface
nsCOMPtr<nsIInputStream> m_inputStream;
// Ouput stream for writing commands to the socket
nsCOMPtr<nsITransport> m_transport;
@ -147,7 +152,7 @@ protected:
PRBool m_socketIsOpen; // mscott: we should look into keeping this state in the nsSocketTransport...
// I'm using it to make sure I open the socket the first time a URL is loaded into the connection
PRUint32 m_flags; // used to store flag information
PRUint32 m_startPosition;
//PRUint32 m_startPosition;
PRInt32 m_readCount;
nsFileSpec m_tempMsgFileSpec; // we currently have a hack where displaying a msg involves writing it to a temp file first
@ -197,6 +202,9 @@ public:
// if we suspended the asynch write while waiting for more data to write then this will be TRUE
PRBool mSuspendedWrite;
nsCOMPtr<nsIRequest> m_WriteRequest;
nsCOMPtr<nsIAsyncOutputStream> mAsyncOutStream;
nsCOMPtr<nsIOutputStreamNotify> mProvider;
nsCOMPtr<nsIEventQueue> mProviderEventQ;
// because we are reading the post data in asychronously, it's possible that we aren't sending it
// out fast enough and the reading gets blocked. The following set of state variables are used to

3
mailnews/compose/src/nsMsgAttachmentHandler.cpp
Просмотреть файл

@ -571,8 +571,7 @@ nsMsgAttachmentHandler::SnarfMsgAttachment(nsMsgCompFields *compFields)
if (aURL)
aURL->SetSpec(nsDependentCString(uri.get()));
rv = NS_NewInputStreamChannel(getter_AddRefs(m_converter_channel), aURL, nsnull,
NS_LITERAL_CSTRING(""), NS_LITERAL_CSTRING(""), -1);
rv = NS_NewInputStreamChannel(getter_AddRefs(m_converter_channel), aURL, nsnull);
if (NS_FAILED(rv))
goto done;

2
mailnews/compose/src/nsMsgAttachmentHandler.h
Просмотреть файл

@ -42,7 +42,7 @@
#include "nsIMimeConverter.h"
#include "nsMsgCompFields.h"
#include "nsIMsgStatusFeedback.h"
#include "nsIRequest.h"
#include "nsIChannel.h"
#include "nsIMsgSend.h"
#include "nsIFileStreams.h"
#include "nsIStreamConverter.h"

3
mailnews/compose/src/nsMsgCreate.cpp
Просмотреть файл

@ -173,8 +173,7 @@ nsMsgDraft::ProcessDraftOrTemplateOperation(const char *msgURI, nsMimeOutputType
}
nsCOMPtr<nsIChannel> dummyChannel;
rv = NS_NewInputStreamChannel(getter_AddRefs(dummyChannel), aURL, nsnull,
NS_LITERAL_CSTRING(""), NS_LITERAL_CSTRING(""), -1);
rv = NS_NewInputStreamChannel(getter_AddRefs(dummyChannel), aURL, nsnull);
if (NS_FAILED(mimeParser->AsyncConvertData(nsnull, nsnull, nsnull, dummyChannel)))
{
Release();

9
mailnews/compose/src/nsSmtpProtocol.cpp
Просмотреть файл

@ -46,6 +46,7 @@
#include "nsIStreamListener.h"
#include "nsIInputStream.h"
#include "nsIOutputStream.h"
#include "nsISocketTransport.h"
#include "nsIMsgHeaderParser.h"
#include "nsFileStream.h"
#include "nsIMsgMailNewsUrl.h"
@ -712,14 +713,10 @@ PRInt32 nsSmtpProtocol::SendTLSResponse()
if (m_responseCode == 220)
{
nsCOMPtr<nsISupports> secInfo;
nsCOMPtr<nsITransport> trans;
nsCOMPtr<nsITransportRequest> transReq = do_QueryInterface(m_request, &rv);
nsCOMPtr<nsISocketTransport> strans = do_QueryInterface(m_transport, &rv);
if (NS_FAILED(rv)) return rv;
rv = transReq->GetTransport(getter_AddRefs(trans));
if (NS_FAILED(rv)) return rv;
rv = trans->GetSecurityInfo(getter_AddRefs(secInfo));
rv = strans->GetSecurityInfo(getter_AddRefs(secInfo));
if (NS_SUCCEEDED(rv) && secInfo) {
nsCOMPtr<nsISSLSocketControl> sslControl = do_QueryInterface(secInfo, &rv);

271
mailnews/imap/src/nsImapProtocol.cpp
Просмотреть файл

@ -104,6 +104,7 @@ PRLogModuleInfo *IMAP;
#include "nsIProxyObjectManager.h"
#include "nsIStreamConverterService.h"
#include "nsIProxyInfo.h"
#include "nsEventQueueUtils.h"
#if 0
#include "nsIHashAlgorithm.h"
#endif
@ -413,6 +414,8 @@ nsImapProtocol::nsImapProtocol() :
m_dataOutputBuf = (char *) PR_CALLOC(sizeof(char) * OUTPUT_BUFFER_SIZE);
m_allocatedSize = OUTPUT_BUFFER_SIZE;
m_pumpSuspended = PR_FALSE;
// used to buffer incoming data by ReadNextLineFromInput
m_inputStreamBuffer = new nsMsgLineStreamBuffer(OUTPUT_BUFFER_SIZE, PR_TRUE /* allocate new lines */, PR_FALSE /* leave CRLFs on the returned string */);
m_currentBiffState = nsIMsgFolder::nsMsgBiffState_Unknown;
@ -735,7 +738,7 @@ nsresult nsImapProtocol::SetupWithUrl(nsIURI * aURL, nsISupports* aConsumer)
imapServer->GetFetchByChunks(&m_fetchByChunks);
}
if ( m_runningUrl && !m_channel /* and we don't have a transport yet */)
if ( m_runningUrl && !m_transport /* and we don't have a transport yet */)
{
// extract the file name and create a file transport...
PRInt32 port=-1;
@ -771,35 +774,67 @@ nsresult nsImapProtocol::SetupWithUrl(nsIURI * aURL, nsISupports* aConsumer)
rv = NS_ExamineForProxy("imap", hostName.get(), port, getter_AddRefs(proxyInfo));
if (NS_FAILED(rv)) proxyInfo = nsnull;
const nsACString *socketHost;
PRUint16 socketPort;
if (m_overRideUrlConnectionInfo)
rv = socketService->CreateTransportOfType(connectionType, m_logonHost.get(), m_logonPort, proxyInfo, 0, 0, getter_AddRefs(m_channel));
else
rv = socketService->CreateTransportOfType(connectionType, hostName, port, proxyInfo, 0, 0, getter_AddRefs(m_channel));
// Ensure that the socket can get the notification callbacks
nsCOMPtr<nsIInterfaceRequestor> callbacks;
m_mockChannel->GetNotificationCallbacks(getter_AddRefs(callbacks));
if (m_channel)
{
m_channel->SetNotificationCallbacks(callbacks, PR_FALSE);
socketHost = &m_logonHost;
socketPort = m_logonPort;
}
else
{
socketHost = &hostName;
socketPort = port;
}
rv = socketService->CreateTransport(&connectionType, connectionType != nsnull,
*socketHost, socketPort, proxyInfo,
getter_AddRefs(m_transport));
if (NS_SUCCEEDED(rv))
rv = m_channel->OpenOutputStream(0, PRUint32(-1), 0, getter_AddRefs(m_outputStream));
if (m_transport)
{
// Ensure that the socket can get the notification callbacks
nsCOMPtr<nsIInterfaceRequestor> callbacks;
m_mockChannel->GetNotificationCallbacks(getter_AddRefs(callbacks));
if (callbacks)
m_transport->SetSecurityCallbacks(callbacks);
nsCOMPtr<nsITransportEventSink> sink = do_QueryInterface(m_mockChannel);
if (sink) {
nsCOMPtr<nsIEventQueue> eventQ;
NS_GetMainEventQ(getter_AddRefs(eventQ));
m_transport->SetEventSink(sink, eventQ);
}
// open buffered, asynchronous input stream
rv = m_transport->OpenInputStream(0, 0, 0, getter_AddRefs(m_inputStream));
if (NS_FAILED(rv)) return rv;
// open buffered, blocking output stream
rv = m_transport->OpenOutputStream(nsITransport::OPEN_BLOCKING, 0, 0, getter_AddRefs(m_outputStream));
if (NS_FAILED(rv)) return rv;
}
}
} // if m_runningUrl
if (m_channel && m_mockChannel)
if (m_transport && m_mockChannel)
{
// set the security info for the mock channel to be the security status for our underlying transport.
nsCOMPtr<nsISupports> securityInfo;
m_channel->GetSecurityInfo(getter_AddRefs(securityInfo));
m_transport->GetSecurityInfo(getter_AddRefs(securityInfo));
m_mockChannel->SetSecurityInfo(securityInfo);
nsCOMPtr<nsIInterfaceRequestor> callbacks;
m_mockChannel->GetNotificationCallbacks(getter_AddRefs(callbacks));
if (callbacks && m_channel)
m_channel->SetNotificationCallbacks(callbacks, PR_FALSE);
if (callbacks && m_transport)
m_transport->SetSecurityCallbacks(callbacks);
nsCOMPtr<nsITransportEventSink> sink = do_QueryInterface(m_mockChannel);
if (sink) {
nsCOMPtr<nsIEventQueue> eventQ;
NS_GetMainEventQ(getter_AddRefs(eventQ));
m_transport->SetEventSink(sink, eventQ);
}
// and if we have a cache entry that we are saving the message to, set the security info on it too.
// since imap only uses the memory cache, passing this on is the right thing to do.
@ -822,8 +857,11 @@ nsresult nsImapProtocol::SetupWithUrl(nsIURI * aURL, nsISupports* aConsumer)
void nsImapProtocol::ReleaseUrlState()
{
// clear out the socket's reference to the notification callbacks for this transaction
if (m_channel)
m_channel->SetNotificationCallbacks(nsnull, PR_FALSE);
if (m_transport)
{
m_transport->SetSecurityCallbacks(nsnull);
m_transport->SetEventSink(nsnull, nsnull);
}
if (m_mockChannel)
{
@ -923,7 +961,8 @@ NS_IMETHODIMP nsImapProtocol::Run()
}
me->m_runningUrl = nsnull;
me->m_channel = nsnull;
me->m_transport = nsnull;
me->m_inputStream = nsnull;
me->m_outputStream = nsnull;
me->m_channelListener = nsnull;
me->m_channelContext = nsnull;
@ -1030,8 +1069,8 @@ nsImapProtocol::TellThreadToDie(PRBool isSaveToClose)
}
}
if (mAsyncReadRequest)
mAsyncReadRequest->Cancel(NS_OK);
if (m_pump)
m_pump->Cancel(NS_ERROR_ABORT);
PR_EnterMonitor(m_threadDeathMonitor);
m_threadShouldDie = PR_TRUE;
PR_ExitMonitor(m_threadDeathMonitor);
@ -1114,7 +1153,7 @@ nsImapProtocol::ImapThreadMainLoop()
// process the current url. Don't try to wait for the monitor
// the first time because it may have already been signaled.
// But make sure we have a channel first, or ProcessCurrentUrl will fail.
if (TestFlag(IMAP_FIRST_PASS_IN_THREAD) && m_runningUrl && m_channel)
if (TestFlag(IMAP_FIRST_PASS_IN_THREAD) && m_runningUrl && m_transport)
{
// if we launched another url, just loop around and process it.
if (ProcessCurrentURL())
@ -1202,13 +1241,19 @@ PRBool nsImapProtocol::ProcessCurrentURL()
PRBool isExternalUrl;
nsresult rv = NS_OK;
PseudoInterrupt(PR_FALSE); // clear this if left over from previous url.
if (!TestFlag(IMAP_CONNECTION_IS_OPEN) && m_channel)
if (!TestFlag(IMAP_CONNECTION_IS_OPEN) && m_inputStream)
{
m_channel->AsyncRead(this /* stream listener */, nsnull, 0, PRUint32(-1), 0,
getter_AddRefs(mAsyncReadRequest));
SetFlag(IMAP_CONNECTION_IS_OPEN);
rv = NS_NewInputStreamPump(getter_AddRefs(m_pump), m_inputStream);
if (NS_SUCCEEDED(rv))
{
rv = m_pump->AsyncRead(this /* stream listener */, nsnull);
if (NS_SUCCEEDED(rv))
SetFlag(IMAP_CONNECTION_IS_OPEN);
}
}
if (m_runningUrl)
{
@ -1244,7 +1289,6 @@ PRBool nsImapProtocol::ProcessCurrentURL()
GetServerStateParser().SetConnected(PR_TRUE);
// acknowledge that we are running the url now..
nsresult rv = NS_OK;
nsCOMPtr<nsIMsgMailNewsUrl> mailnewsurl = do_QueryInterface(m_runningUrl, &rv);
#ifdef DEBUG_bienvenu1
nsXPIDLCString urlSpec;
@ -1425,26 +1469,30 @@ void nsImapProtocol::ParseIMAPandCheckForNewMail(const char* commandString, PRBo
////////////////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP nsImapProtocol::OnDataAvailable(nsIRequest *request, nsISupports *ctxt, nsIInputStream *aIStream, PRUint32 aSourceOffset, PRUint32 aLength)
{
nsresult res = NS_OK;
if(NS_SUCCEEDED(res) && aLength > 0)
{
if (aLength > 0)
{
// make sure m_inputStream is set to the right input stream...
if (!m_inputStream)
m_inputStream = dont_QueryInterface(aIStream);
NS_ASSERTION(m_inputStream == aIStream, "unexpected stream");
if (TestFlag(IMAP_WAITING_FOR_DATA))
{
// if we received data, we need to signal the data available monitor...
if (TestFlag(IMAP_WAITING_FOR_DATA))
{
// if we received data, we need to signal the data available monitor...
// Read next line from input will actually read the data out of the stream
ClearFlag(IMAP_WAITING_FOR_DATA); // we are no longer waiting for data
PR_EnterMonitor(m_dataAvailableMonitor);
ClearFlag(IMAP_WAITING_FOR_DATA); // we are no longer waiting for data
// XXX no one ever waits on this monitor!
PR_EnterMonitor(m_dataAvailableMonitor);
PR_Notify(m_dataAvailableMonitor);
PR_ExitMonitor(m_dataAvailableMonitor);
}
PR_ExitMonitor(m_dataAvailableMonitor);
}
// suspend this request until we've read from the input stream
NS_ASSERTION(m_pump == request, "unexpected request");
request->Suspend();
m_pumpSuspended = PR_TRUE;
}
return res;
return NS_OK;
}
NS_IMETHODIMP nsImapProtocol::OnStartRequest(nsIRequest *request, nsISupports *ctxt)
@ -1466,7 +1514,6 @@ NS_IMETHODIMP nsImapProtocol::OnStartRequest(nsIRequest *request, nsISupports *c
// stop binding is a "notification" informing us that the stream associated with aURL is going away.
NS_IMETHODIMP nsImapProtocol::OnStopRequest(nsIRequest *request, nsISupports *ctxt, nsresult aStatus)
{
PRBool killThread = PR_TRUE; // we always want to kill the thread, I believe.
if (NS_FAILED(aStatus))
@ -1509,14 +1556,14 @@ NS_IMETHODIMP nsImapProtocol::OnStopRequest(nsIRequest *request, nsISupports *ct
}
PR_CEnterMonitor(this);
mAsyncReadRequest = nsnull; // don't need to cache this anymore, it's going away
m_pump = nsnull; // don't need to cache this anymore, it's going away
if (killThread == PR_TRUE)
{
ClearFlag(IMAP_CONNECTION_IS_OPEN);
TellThreadToDie(PR_FALSE);
}
m_channel = nsnull;
m_transport = nsnull;
m_outputStream = nsnull;
m_inputStream = nsnull;
PR_CExitMonitor(this);
@ -1558,10 +1605,9 @@ NS_IMETHODIMP nsImapProtocol::GetRunningImapURL(nsIImapUrl **aImapUrl)
nsresult nsImapProtocol::SendData(const char * dataBuffer, PRBool aSuppressLogging)
{
PRUint32 writeCount = 0;
nsresult rv = NS_ERROR_NULL_POINTER;
if (!m_channel)
if (!m_transport)
{
// the connection died unexpectedly! so clear the open connection flag
ClearFlag(IMAP_CONNECTION_IS_OPEN);
@ -1577,7 +1623,10 @@ nsresult nsImapProtocol::SendData(const char * dataBuffer, PRBool aSuppressLoggi
Log("SendData", nsnull, dataBuffer);
else
Log("SendData", nsnull, "Logging suppressed for this command (it probably contained authentication information)");
rv = m_outputStream->Write(dataBuffer, PL_strlen(dataBuffer), &writeCount);
PRUint32 n;
rv = m_outputStream->Write(dataBuffer, PL_strlen(dataBuffer), &n);
if (NS_FAILED(rv))
{
// the connection died unexpectedly! so clear the open connection flag
@ -1615,7 +1664,7 @@ nsresult nsImapProtocol::LoadUrl(nsIURI * aURL, nsISupports * aConsumer)
if (NS_FAILED(rv)) return rv;
SetupSinkProxy(); // generate proxies for all of the event sinks in the url
m_lastActiveTime = PR_Now();
if (m_channel && m_runningUrl)
if (m_transport && m_runningUrl)
{
nsImapAction imapAction;
m_runningUrl->GetImapAction(&imapAction);
@ -1650,7 +1699,7 @@ NS_IMETHODIMP nsImapProtocol::IsBusy(PRBool *aIsConnectionBusy,
nsresult rv = NS_OK;
*aIsConnectionBusy = PR_FALSE;
*isInboxConnection = PR_FALSE;
if (!m_channel)
if (!m_transport)
{
// ** jt -- something is really wrong kill the thread
TellThreadToDie(PR_FALSE);
@ -1694,7 +1743,7 @@ NS_IMETHODIMP nsImapProtocol::CanHandleUrl(nsIImapUrl * aImapUrl,
PRBool isBusy = PR_FALSE;
PRBool isInboxConnection = PR_FALSE;
if (!m_channel)
if (!m_transport)
{
// *** jt -- something is really wrong; it could be the dialer gave up
// the connection or ip binding has been release by the operating
@ -4045,9 +4094,20 @@ char* nsImapProtocol::CreateNewLineFromSocket()
{
m_eventQueue->ProcessPendingEvents();
newLine = m_inputStreamBuffer->ReadNextLine(m_inputStream, numBytesInLine, needMoreData);
PR_LOG(IMAP, PR_LOG_DEBUG, ("ReadNextLine [stream=%x nb=%u needmore=%u]\n",
m_inputStream.get(), numBytesInLine, needMoreData));
if (needMoreData)
{
SetFlag(IMAP_WAITING_FOR_DATA);
if (m_pump && m_pumpSuspended)
{
m_pump->Resume();
m_pumpSuspended = PR_FALSE;
}
// we want to put this thread to rest until the on data available monitor goes off..
// so sleep until the timeout hits, then pump some events. This may cause the IMAP_WAITING_FOR_DATA
// flag to get cleared which means data has arrived so we can kick out of the loop or the
@ -7374,6 +7434,7 @@ NS_INTERFACE_MAP_BEGIN(nsImapMockChannel)
NS_INTERFACE_MAP_ENTRY(nsIChannel)
NS_INTERFACE_MAP_ENTRY(nsIRequest)
NS_INTERFACE_MAP_ENTRY(nsICacheListener)
NS_INTERFACE_MAP_ENTRY(nsITransportEventSink)
NS_INTERFACE_MAP_END_THREADSAFE
@ -7589,19 +7650,14 @@ nsImapMockChannel::OnCacheEntryAvailable(nsICacheEntryDescriptor *entry, nsCache
nsCOMPtr<nsIStreamListenerTee> tee = do_CreateInstance(kStreamListenerTeeCID, &rv);
if (NS_SUCCEEDED(rv))
{
nsCOMPtr<nsITransport> transport;
rv = entry->GetTransport(getter_AddRefs(transport));
nsCOMPtr<nsIOutputStream> out;
// this will fail with the mem cache turned off, so we need to fall through
// to ReadFromImapConnection instead of aborting with NS_ENSURE_SUCCESS(rv,rv)
rv = entry->OpenOutputStream(0, getter_AddRefs(out));
if (NS_SUCCEEDED(rv))
{
nsCOMPtr<nsIOutputStream> out;
// this will fail with the mem cache turned off, so we need to fall through
// to ReadFromImapConnection instead of aborting with NS_ENSURE_SUCCESS(rv,rv)
rv = transport->OpenOutputStream(0, PRUint32(-1), 0, getter_AddRefs(out));
if (NS_SUCCEEDED(rv))
{
rv = tee->Init(m_channelListener, out);
m_channelListener = do_QueryInterface(tee);
}
rv = tee->Init(m_channelListener, out);
m_channelListener = do_QueryInterface(tee);
}
}
}
@ -7701,36 +7757,41 @@ nsresult nsImapMockChannel::ReadFromMemCache(nsICacheEntryDescriptor *entry)
}
if (shouldUseCacheEntry)
{
nsCOMPtr<nsITransport> cacheTransport;
rv = entry->GetTransport(getter_AddRefs(cacheTransport));
if (NS_SUCCEEDED(rv))
nsCOMPtr<nsIInputStream> in;
rv = entry->OpenInputStream(0, getter_AddRefs(in));
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIInputStreamPump> pump;
rv = NS_NewInputStreamPump(getter_AddRefs(pump), in);
if (NS_FAILED(rv)) return rv;
// if we are going to read from the cache, then create a mock stream listener class and use it
nsImapCacheStreamListener * cacheListener = new nsImapCacheStreamListener();
NS_ADDREF(cacheListener);
cacheListener->Init(m_channelListener, NS_STATIC_CAST(nsIChannel *, this));
rv = pump->AsyncRead(cacheListener, m_channelContext);
NS_RELEASE(cacheListener);
if (NS_SUCCEEDED(rv)) // ONLY if we succeeded in actually starting the read should we return
{
// if we are going to read from the cache, then create a mock stream listener class and use it
nsImapCacheStreamListener * cacheListener = new nsImapCacheStreamListener();
NS_ADDREF(cacheListener);
cacheListener->Init(m_channelListener, NS_STATIC_CAST(nsIChannel *, this));
rv = cacheTransport->AsyncRead(cacheListener, m_channelContext, 0, PRUint32(-1), 0, getter_AddRefs(mCacheRequest));
NS_RELEASE(cacheListener);
mCacheRequest = pump;
if (NS_SUCCEEDED(rv)) // ONLY if we succeeded in actually starting the read should we return
{
nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(m_url);
nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(m_url);
// if the msg is unread, we should mark it read on the server. This lets
// the code running this url we're loading from the cache, if it cares.
imapUrl->SetMsgLoadingFromCache(PR_TRUE);
// if the msg is unread, we should mark it read on the server. This lets
// the code running this url we're loading from the cache, if it cares.
imapUrl->SetMsgLoadingFromCache(PR_TRUE);
// and force the url to remove its reference on the mock channel...this is to solve
// a nasty reference counting problem...
imapUrl->SetMockChannel(nsnull);
// and force the url to remove its reference on the mock channel...this is to solve
// a nasty reference counting problem...
imapUrl->SetMockChannel(nsnull);
// be sure to set the cache entry's security info status as our security info status...
nsCOMPtr<nsISupports> securityInfo;
entry->GetSecurityInfo(getter_AddRefs(securityInfo));
SetSecurityInfo(securityInfo);
return NS_OK;
} // if AsyncRead succeeded.
} // if get transport succeeded
// be sure to set the cache entry's security info status as our security info status...
nsCOMPtr<nsISupports> securityInfo;
entry->GetSecurityInfo(getter_AddRefs(securityInfo));
SetSecurityInfo(securityInfo);
return NS_OK;
} // if AsyncRead succeeded.
} // if contnet is not modified
else
rv = NS_ERROR_FAILURE; // content is modified so return an error so we try to open it the old fashioned way
@ -7791,13 +7852,13 @@ PRBool nsImapMockChannel::ReadFromLocalCache()
if (folder && NS_SUCCEEDED(rv))
{
// we want to create a file channel and read the msg from there.
nsCOMPtr<nsITransport> fileChannel;
nsCOMPtr<nsIInputStream> fileStream;
nsMsgKey msgKey = atoi(messageIdString);
PRUint32 size, offset;
rv = folder->GetOfflineFileTransport(msgKey, &offset, &size, getter_AddRefs(fileChannel));
rv = folder->GetOfflineFileStream(msgKey, &offset, &size, getter_AddRefs(fileStream));
// get the file channel from the folder, somehow (through the message or
// folder sink?) We also need to set the transfer offset to the message offset
if (fileChannel && NS_SUCCEEDED(rv))
if (fileStream && NS_SUCCEEDED(rv))
{
// dougt - This may break the ablity to "cancel" a read from offline mail reading.
// fileChannel->SetLoadGroup(m_loadGroup);
@ -7809,8 +7870,13 @@ PRBool nsImapMockChannel::ReadFromLocalCache()
nsImapCacheStreamListener * cacheListener = new nsImapCacheStreamListener();
NS_ADDREF(cacheListener);
cacheListener->Init(m_channelListener, NS_STATIC_CAST(nsIChannel *, this));
nsCOMPtr<nsIRequest> request;
rv = fileChannel->AsyncRead(cacheListener, m_channelContext, offset, size, 0, getter_AddRefs(request));
// create a stream pump that will async read the specified amount of data.
nsCOMPtr<nsIInputStreamPump> pump;
rv = NS_NewInputStreamPump(getter_AddRefs(pump), fileStream, offset, size);
if (NS_SUCCEEDED(rv))
rv = pump->AsyncRead(cacheListener, m_channelContext);
NS_RELEASE(cacheListener);
if (NS_SUCCEEDED(rv)) // ONLY if we succeeded in actually starting the read should we return
@ -8082,3 +8148,26 @@ nsImapMockChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aNotification
return NS_OK;
}
NS_IMETHODIMP
nsImapMockChannel::OnTransportStatus(nsITransport *transport, nsresult status,
PRUint32 progress, PRUint32 progressMax)
{
if (mProgressEventSink && !(mLoadFlags & LOAD_BACKGROUND))
{
// these transport events should not generate any status messages
if (status == nsISocketTransport::STATUS_RECEIVING_FROM ||
status == nsISocketTransport::STATUS_SENDING_TO)
{
mProgressEventSink->OnProgress(this, nsnull, progress, progressMax);
}
else
{
nsCAutoString host;
if (m_url)
m_url->GetHost(host);
mProgressEventSink->OnStatus(this, nsnull, status, NS_ConvertUTF8toUCS2(host).get());
}
}
return NS_OK;
}

18
mailnews/imap/src/nsImapProtocol.h
Просмотреть файл

@ -51,7 +51,8 @@
#include "nsIProgressEventSink.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsITransport.h"
#include "nsISocketTransport.h"
#include "nsIInputStreamPump.h"
// imap event sinks
#include "nsIImapMailFolderSink.h"
@ -390,16 +391,18 @@ private:
nsCAutoString m_trashFolderName;
// Ouput stream for writing commands to the socket
nsCOMPtr<nsITransport> m_channel;
nsCOMPtr<nsIOutputStream> m_outputStream; // this will be obtained from the transport interface
nsCOMPtr<nsIInputStream> m_inputStream;
nsCOMPtr<nsISocketTransport> m_transport;
nsCOMPtr<nsIOutputStream> m_outputStream; // this will be obtained from the transport interface
nsCOMPtr<nsIInputStream> m_inputStream;
nsCOMPtr<nsIInputStreamPump> m_pump;
PRBool m_pumpSuspended;
nsCOMPtr<nsIInputStream> m_channelInputStream;
nsCOMPtr<nsIOutputStream> m_channelOutputStream;
nsCOMPtr<nsIStreamListener> m_channelListener; // if we are displaying an article this is the rfc-822 display sink...
nsCOMPtr<nsISupports> m_channelContext;
nsCOMPtr<nsIImapMockChannel> m_mockChannel; // this is the channel we should forward to people
nsCOMPtr<nsIRequest> mAsyncReadRequest; // we're going to cancel this when we're done with the conn.
//nsCOMPtr<nsIRequest> mAsyncReadRequest; // we're going to cancel this when we're done with the conn.
// this is a method designed to buffer data coming from the input stream and efficiently extract out
@ -669,7 +672,9 @@ private:
class nsICacheEntryDescriptor;
class nsImapMockChannel : public nsIImapMockChannel, public nsICacheListener
class nsImapMockChannel : public nsIImapMockChannel
, public nsICacheListener
, public nsITransportEventSink
{
public:
@ -678,6 +683,7 @@ public:
NS_DECL_NSICHANNEL
NS_DECL_NSIREQUEST
NS_DECL_NSICACHELISTENER
NS_DECL_NSITRANSPORTEVENTSINK
nsImapMockChannel();
virtual ~nsImapMockChannel();

1
mailnews/import/comm4x/src/nsComm4xProfile.cpp
Просмотреть файл

@ -42,6 +42,7 @@
#include "nsILineInputStream.h"
#include "nsReadableUtils.h"
#include "nsIPrefMigration.h"
#include "nsNetCID.h"
nsComm4xProfile::nsComm4xProfile()

66
mailnews/local/src/nsMailboxProtocol.cpp
Просмотреть файл

@ -61,11 +61,10 @@
#include "nsFileStream.h"
PRLogModuleInfo *MAILBOX;
#include "nsIFileChannel.h"
#include "nsIFileStreams.h"
#include "nsIStreamTransportService.h"
#include "nsIStreamConverterService.h"
#include "nsIIOService.h"
#include "nsIFileTransportService.h"
#include "nsXPIDLString.h"
#include "nsNetUtil.h"
#include "nsIMsgWindow.h"
@ -128,44 +127,42 @@ NS_IMETHODIMP nsMailboxProtocol::GetContentLength(PRInt32 * aContentLength)
return NS_OK;
}
nsresult nsMailboxProtocol::OpenMultipleMsgTransport(PRUint32 offset, PRInt32 size)
{
nsresult rv;
NS_DEFINE_CID(kStreamTransportServiceCID, NS_STREAMTRANSPORTSERVICE_CID);
nsCOMPtr<nsIStreamTransportService> serv =
do_GetService(kStreamTransportServiceCID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = serv->CreateInputTransport(m_multipleMsgMoveCopyStream, offset, size, PR_FALSE, getter_AddRefs(m_transport));
return rv;
}
nsresult nsMailboxProtocol::OpenFileSocketForReuse(nsIURI * aURL, PRUint32 aStartPosition, PRInt32 aReadCount)
{
NS_ENSURE_ARG_POINTER(aURL);
nsresult rv = NS_OK;
m_startPosition = aStartPosition;
m_readCount = aReadCount;
nsCOMPtr <nsIFile> file;
rv = GetFileFromURL(aURL, getter_AddRefs(file));
NS_ENSURE_SUCCESS(rv, rv);
NS_DEFINE_CID(kFileTransportServiceCID, NS_FILETRANSPORTSERVICE_CID);
nsCOMPtr<nsIFileTransportService> fts =
do_GetService(kFileTransportServiceCID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIFileInputStream> fileStream = do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv);
nsCOMPtr<nsIFileInputStream> fileStream = do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
m_multipleMsgMoveCopyStream = do_QueryInterface(fileStream, &rv);
NS_ENSURE_SUCCESS(rv, rv);
fileStream->Init(file, PR_RDONLY, 0664, PR_FALSE); //just have to read the messages
PRUint32 length;
PRInt64 fileSize;
rv = file->GetFileSize( &fileSize);
LL_L2UI( length, fileSize );
// probably should pass in the file size instead of aReadCount
rv = fts->CreateTransportFromStream(NS_LITERAL_CSTRING("mailbox"),
m_multipleMsgMoveCopyStream,
NS_LITERAL_CSTRING(""),
NS_LITERAL_CSTRING(""),
length, PR_FALSE, getter_AddRefs(m_transport));
rv = OpenMultipleMsgTransport(aStartPosition, aReadCount);
m_socketIsOpen = PR_FALSE;
return rv;
}
@ -329,8 +326,32 @@ NS_IMETHODIMP nsMailboxProtocol::OnStopRequest(nsIRequest *request, nsISupports
// basically re-initialize the transport with the correct message size.
// then, we have to make sure the url keeps running somehow.
nsCOMPtr<nsISupports> urlSupports = do_QueryInterface(m_runningUrl);
//
// put us in a state where we are always notified of incoming data
rv = m_transport->AsyncRead(this, urlSupports, msgKey, msgSize, 0, getter_AddRefs(m_request));
//
m_transport = 0; // open new stream transport
m_inputStream = 0;
m_outputStream = 0;
rv = OpenMultipleMsgTransport(msgKey, msgSize);
if (NS_SUCCEEDED(rv))
{
if (!m_inputStream)
rv = m_transport->OpenInputStream(0, 0, 0, getter_AddRefs(m_inputStream));
if (NS_SUCCEEDED(rv))
{
nsCOMPtr<nsIInputStreamPump> pump;
rv = NS_NewInputStreamPump(getter_AddRefs(pump), m_inputStream);
if (NS_SUCCEEDED(rv)) {
rv = pump->AsyncRead(this, urlSupports);
if (NS_SUCCEEDED(rv))
m_request = pump;
}
}
}
NS_ASSERTION(NS_SUCCEEDED(rv), "AsyncRead failed");
if (m_loadGroup)
m_loadGroup->RemoveRequest(NS_STATIC_CAST(nsIRequest *, this), nsnull, aStatus);
@ -795,3 +816,4 @@ nsresult nsMailboxProtocol::CloseSocket()
return 0;
}
// vim: ts=2 sw=2

1
mailnews/local/src/nsMailboxProtocol.h
Просмотреть файл

@ -127,6 +127,7 @@ private:
virtual nsresult CloseSocket();
PRInt32 SetupMessageExtraction();
nsresult OpenMultipleMsgTransport(PRUint32 offset, PRInt32 size);
nsresult OpenFileSocketForReuse(nsIURI * aURL, PRUint32 aStartPosition, PRInt32 aReadCount);
PRBool RunningMultipleMsgUrl();

72
mailnews/mime/emitters/src/nsMimeBaseEmitter.cpp
Просмотреть файл

@ -78,8 +78,6 @@ NS_IMPL_THREADSAFE_RELEASE(nsMimeBaseEmitter)
NS_INTERFACE_MAP_BEGIN(nsMimeBaseEmitter)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIMimeEmitter)
NS_INTERFACE_MAP_ENTRY(nsIMimeEmitter)
NS_INTERFACE_MAP_ENTRY(nsIInputStreamObserver)
NS_INTERFACE_MAP_ENTRY(nsIOutputStreamObserver)
NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
NS_INTERFACE_MAP_END
@ -345,51 +343,6 @@ nsMimeBaseEmitter::LocalizeHeaderName(const char *aHeaderName, const char *aDefa
return nsCRT::strdup(aDefaultName);
}
///////////////////////////////////////////////////////////////////////////
// nsIPipeObserver Interface
///////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP nsMimeBaseEmitter::OnWrite(nsIOutputStream* out, PRUint32 aCount)
{
return NS_OK;
}
NS_IMETHODIMP nsMimeBaseEmitter::OnEmpty(nsIInputStream* in)
{
return NS_OK;
}
NS_IMETHODIMP nsMimeBaseEmitter::OnFull(nsIOutputStream* out)
{
// the pipe is full so we should flush our data to the converter's listener
// in order to make more room.
// since we only have one pipe per mime emitter, i can ignore the pipe param and use
// my outStream object directly (it will be the same thing as what we'd get from aPipe.
nsresult rv = NS_OK;
if (mOutListener && mInputStream)
{
PRUint32 bytesAvailable = 0;
rv = mInputStream->Available(&bytesAvailable);
NS_ASSERTION(NS_SUCCEEDED(rv), "Available failed");
nsCOMPtr<nsIRequest> request = do_QueryInterface(mChannel);
rv = mOutListener->OnDataAvailable(request, mURL, mInputStream, 0, bytesAvailable);
}
else
rv = NS_ERROR_NULL_POINTER;
return rv;
}
NS_IMETHODIMP nsMimeBaseEmitter::OnClose(nsIInputStream* in)
{
return NS_OK;
}
///////////////////////////////////////////////////////////////////////////
// nsMimeBaseEmitter Interface
///////////////////////////////////////////////////////////////////////////
@ -537,8 +490,7 @@ nsMimeBaseEmitter::Write(const char *buf, PRUint32 size, PRUint32 *amountWritten
// First, handle any old buffer data...
if (needToWrite > 0)
{
rv = mOutStream->Write(mBufferMgr->GetBuffer(),
needToWrite, &written);
rv = WriteHelper(mBufferMgr->GetBuffer(), needToWrite, &written);
mTotalWritten += written;
mBufferMgr->ReduceBuffer(written);
@ -556,7 +508,7 @@ nsMimeBaseEmitter::Write(const char *buf, PRUint32 size, PRUint32 *amountWritten
// if we get here, we are dealing with new data...try to write
// and then do the right thing...
rv = mOutStream->Write(buf, size, &written);
rv = WriteHelper(buf, size, &written);
*amountWritten = written;
mTotalWritten += written;
@ -566,6 +518,26 @@ nsMimeBaseEmitter::Write(const char *buf, PRUint32 size, PRUint32 *amountWritten
return rv;
}
nsresult
nsMimeBaseEmitter::WriteHelper(const char *buf, PRUint32 count, PRUint32 *countWritten)
{
nsresult rv;
rv = mOutStream->Write(buf, count, countWritten);
if (rv == NS_BASE_STREAM_WOULD_BLOCK) {
// pipe is full, push contents of pipe to listener...
PRUint32 avail;
rv = mInputStream->Available(&avail);
if (NS_SUCCEEDED(rv) && avail) {
mOutListener->OnDataAvailable(mChannel, mURL, mInputStream, 0, avail);
// try writing again...
rv = mOutStream->Write(buf, count, countWritten);
}
}
return rv;
}
//
// Find a cached header! Note: Do NOT free this value!
//

11
mailnews/mime/emitters/src/nsMimeBaseEmitter.h
Просмотреть файл

@ -44,8 +44,7 @@
#include "nsIStreamListener.h"
#include "nsIInputStream.h"
#include "nsIOutputStream.h"
#include "nsIObservableInputStream.h"
#include "nsIObservableOutputStream.h"
#include "nsIAsyncInputStream.h"
#include "nsIURI.h"
#include "nsIPref.h"
#include "nsIChannel.h"
@ -87,9 +86,7 @@ typedef struct {
} headerInfoType;
class nsMimeBaseEmitter : public nsIMimeEmitter,
public nsIInterfaceRequestor,
public nsIInputStreamObserver,
public nsIOutputStreamObserver
public nsIInterfaceRequestor
{
public:
nsMimeBaseEmitter ();
@ -99,8 +96,6 @@ public:
NS_DECL_ISUPPORTS
NS_DECL_NSIMIMEEMITTER
NS_DECL_NSIINPUTSTREAMOBSERVER
NS_DECL_NSIOUTPUTSTREAMOBSERVER
NS_DECL_NSIINTERFACEREQUESTOR
// Utility output functions...
@ -129,6 +124,8 @@ protected:
nsresult DumpRestOfHeaders();
nsresult OutputGenericHeader(const char *aHeaderVal);
nsresult WriteHelper(const char *buf, PRUint32 count, PRUint32 *countWritten);
// For string bundle usage...
nsCOMPtr<nsIStringBundle> m_stringBundle; // for translated strings
nsCOMPtr<nsIStringBundle> m_headerStringBundle; // for non-translated header strings

7
mailnews/mime/src/mimemoz2.cpp
Просмотреть файл

@ -1121,15 +1121,12 @@ mime_image_begin(const char *image_url, const char *content_type,
{
mailUrl->CacheCacheEntry(entry);
entry->MarkValid();
nsCOMPtr<nsITransport> transport;
rv = entry->GetTransport(getter_AddRefs(transport));
if (NS_FAILED(rv)) return nsnull;
// remember the content type as meta data so we can pull it out in the imap code
// to feed the cache entry directly to imglib w/o going through mime.
entry->SetMetaDataElement("contentType", content_type);
nsCOMPtr<nsIOutputStream> out;
rv = transport->OpenOutputStream(0, PRUint32(-1), 0, getter_AddRefs(mid->memCacheOutputStream));
rv = entry->OpenOutputStream(0, getter_AddRefs(mid->memCacheOutputStream));
if (NS_FAILED(rv)) return nsnull;
}
}

20
mailnews/mime/src/nsStreamConverter.cpp
Просмотреть файл

@ -70,8 +70,8 @@
#include "nsICategoryManager.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsIObservableInputStream.h"
#include "nsIObservableOutputStream.h"
#include "nsIAsyncInputStream.h"
#include "nsIAsyncOutputStream.h"
#define PREF_MAIL_DISPLAY_GLYPH "mail.display_glyph"
#define PREF_MAIL_DISPLAY_STRUCT "mail.display_struct"
@ -699,22 +699,6 @@ NS_IMETHODIMP nsStreamConverter::Init(nsIURI *aURI, nsIStreamListener * aOutList
NS_STREAM_CONVERTER_BUFFER_SIZE,
PR_TRUE, PR_TRUE);
if (NS_SUCCEEDED(rv))
{
nsCOMPtr<nsIInputStreamObserver> inObs = do_GetInterface(mEmitter, &rv);
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIObservableInputStream> observableIn(do_QueryInterface(mInputStream, &rv));
if (NS_SUCCEEDED(rv))
observableIn->SetObserver(inObs);
}
nsCOMPtr<nsIOutputStreamObserver> outObs = do_GetInterface(mEmitter, &rv);
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIObservableOutputStream> observableOut(do_QueryInterface(mOutputStream, &rv));
if (NS_SUCCEEDED(rv))
observableOut->SetObserver(outObs);
}
}
// initialize our emitter
if (NS_SUCCEEDED(rv) && mEmitter)
{

37
mailnews/news/src/nsNNTPProtocol.cpp
Просмотреть файл

@ -795,11 +795,15 @@ nsresult nsNNTPProtocol::ReadFromMemCache(nsICacheEntryDescriptor *entry)
{
NS_ENSURE_ARG(entry);
nsCOMPtr<nsITransport> cacheTransport;
nsresult rv = entry->GetTransport(getter_AddRefs(cacheTransport));
nsCOMPtr<nsIInputStream> cacheStream;
nsresult rv = entry->OpenInputStream(0, getter_AddRefs(cacheStream));
if (NS_SUCCEEDED(rv))
{
nsCOMPtr<nsIInputStreamPump> pump;
rv = NS_NewInputStreamPump(getter_AddRefs(pump), cacheStream);
if (NS_FAILED(rv)) return rv;
nsXPIDLCString group;
nsXPIDLCString commandSpecificData;
// do this to get m_key set, so that marking the message read will work.
@ -815,9 +819,9 @@ nsresult nsNNTPProtocol::ReadFromMemCache(nsICacheEntryDescriptor *entry)
nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_runningURL);
cacheListener->Init(m_channelListener, NS_STATIC_CAST(nsIChannel *, this), mailnewsUrl);
nsCOMPtr<nsIRequest> request;
m_ContentType = ""; // reset the content type for the upcoming read....
rv = cacheTransport->AsyncRead(cacheListener, m_channelContext, 0, PRUint32(-1), 0, getter_AddRefs(request));
rv = pump->AsyncRead(cacheListener, m_channelContext);
NS_RELEASE(cacheListener);
MarkCurrentMsgRead();
@ -857,23 +861,30 @@ PRBool nsNNTPProtocol::ReadFromLocalCache()
if (folder && NS_SUCCEEDED(rv))
{
// we want to create a file channel and read the msg from there.
nsCOMPtr<nsITransport> fileChannel;
nsCOMPtr<nsIInputStream> fileStream;
PRUint32 offset=0, size=0;
rv = folder->GetOfflineFileTransport(m_key, &offset, &size, getter_AddRefs(fileChannel));
rv = folder->GetOfflineFileStream(m_key, &offset, &size, getter_AddRefs(fileStream));
// get the file channel from the folder, somehow (through the message or
// get the file stream from the folder, somehow (through the message or
// folder sink?) We also need to set the transfer offset to the message offset
if (fileChannel && NS_SUCCEEDED(rv))
if (fileStream && NS_SUCCEEDED(rv))
{
// dougt - This may break the ablity to "cancel" a read from offline mail reading.
// fileChannel->SetLoadGroup(m_loadGroup);
m_typeWanted = ARTICLE_WANTED;
nsNntpCacheStreamListener * cacheListener = new nsNntpCacheStreamListener();
NS_ADDREF(cacheListener);
cacheListener->Init(m_channelListener, NS_STATIC_CAST(nsIChannel *, this), mailnewsUrl);
nsCOMPtr<nsIRequest> request;
rv = fileChannel->AsyncRead(cacheListener, m_channelContext, offset, size, 0, getter_AddRefs(request));
// create a stream pump that will async read the specified amount of data.
nsCOMPtr<nsIInputStreamPump> pump;
rv = NS_NewInputStreamPump(getter_AddRefs(pump),
fileStream, offset, size);
if (NS_SUCCEEDED(rv))
rv = pump->AsyncRead(cacheListener, m_channelContext);
NS_RELEASE(cacheListener);
MarkCurrentMsgRead();
@ -909,12 +920,8 @@ nsNNTPProtocol::OnCacheEntryAvailable(nsICacheEntryDescriptor *entry, nsCacheAcc
nsCOMPtr<nsIStreamListenerTee> tee = do_CreateInstance(kStreamListenerTeeCID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsITransport> transport;
rv = entry->GetTransport(getter_AddRefs(transport));
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIOutputStream> out;
rv = transport->OpenOutputStream(0, PRUint32(-1), 0, getter_AddRefs(out));
rv = entry->OpenOutputStream(0, getter_AddRefs(out));
NS_ENSURE_SUCCESS(rv, rv);
rv = tee->Init(m_channelListener, out);

9
modules/libjar/nsIJARChannel.idl
Просмотреть файл

@ -37,16 +37,7 @@
#include "nsIChannel.idl"
interface nsISimpleEnumerator;
[scriptable, uuid(c7e410d1-85f2-11d3-9f63-006008a6efe9)]
interface nsIJARChannel : nsIChannel
{
/**
* Enumerates all the entries in the JAR (the root URI).
* ARGUMENTS:
* aRoot - a string representing the root dir to enumerate from
* or null to enumerate the whole thing.
*/
nsISimpleEnumerator EnumerateEntries(in string aRoot);
};

1020
modules/libjar/nsJARChannel.cpp
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

118
modules/libjar/nsJARChannel.h
Просмотреть файл

@ -39,104 +39,70 @@
#define nsJARChannel_h__
#include "nsIJARChannel.h"
#include "nsIStreamListener.h"
#include "nsIJARProtocolHandler.h"
#include "nsIJARURI.h"
#include "nsIStreamIO.h"
#include "nsIChannel.h"
#include "nsIZipReader.h"
#include "nsIChannel.h"
#include "nsILoadGroup.h"
#include "nsIInputStreamPump.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsCOMPtr.h"
#include "nsIFile.h"
#include "prmon.h"
#include "nsIProgressEventSink.h"
#include "nsIStreamListener.h"
#include "nsIDownloader.h"
#include "nsIInputStream.h"
#include "nsJARProtocolHandler.h"
#include "nsILoadGroup.h"
#include "nsIFile.h"
#include "nsIURI.h"
#include "nsCOMPtr.h"
#include "nsString.h"
#include "prlog.h"
#ifdef DEBUG
#include "prthread.h"
#endif
class nsJARInputThunk;
class nsIFileChannel;
class nsJARChannel;
//-----------------------------------------------------------------------------
#define NS_JARCHANNEL_CID \
{ /* 0xc7e410d5-0x85f2-11d3-9f63-006008a6efe9 */ \
0xc7e410d5, \
0x85f2, \
0x11d3, \
{0x9f, 0x63, 0x00, 0x60, 0x08, 0xa6, 0xef, 0xe9} \
}
class nsJARChannel : public nsIJARChannel,
public nsIStreamListener,
public nsIStreamIO,
public nsIDownloadObserver
class nsJARChannel : public nsIJARChannel
, public nsIDownloadObserver
, public nsIStreamListener
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIREQUEST
NS_DECL_NSICHANNEL
NS_DECL_NSIJARCHANNEL
NS_DECL_NSIDOWNLOADOBSERVER
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSISTREAMLISTENER
NS_DECL_NSIDOWNLOADOBSERVER
// NS_DECL_NSISTREAMIO and nsIChannel both define (attribute string contentType)
NS_IMETHOD Open();
NS_IMETHOD Close(nsresult status);
NS_IMETHOD GetInputStream(nsIInputStream * *aInputStream);
NS_IMETHOD GetOutputStream(nsIOutputStream * *aOutputStream);
NS_IMETHOD GetName(char * *aName);
nsJARChannel();
virtual ~nsJARChannel();
// Define a Create method to be used with a factory:
static NS_METHOD
Create(nsISupports* aOuter, REFNSIID aIID, void **aResult);
nsresult Init(nsIURI *uri);
nsresult Init(nsJARProtocolHandler* aHandler, nsIURI* uri);
nsresult EnsureJARFileAvailable();
nsresult OpenJARElement();
nsresult AsyncReadJARElement();
nsresult EnsureZipReader();
private:
nsresult CreateJarInput();
nsresult EnsureJarInput(PRBool blocking);
friend class nsJARDownloadObserver;
protected:
nsJARProtocolHandler* mJARProtocolHandler;
nsCOMPtr<nsIJARURI> mURI;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsIURI> mOriginalURI;
nsLoadFlags mLoadFlags;
nsCOMPtr<nsISupports> mOwner;
nsCOMPtr<nsISupports> mUserContext;
nsCOMPtr<nsIStreamListener> mUserListener;
nsCString mContentType;
nsCString mContentCharset;
PRInt32 mContentLength;
nsCOMPtr<nsIURI> mJARBaseURI;
nsCString mJAREntry;
nsCOMPtr<nsIZipReader> mJAR;
nsCOMPtr<nsIFile> mDownloadedJARFile;
nsresult mStatus;
PRBool mSynchronousRead;
nsCOMPtr<nsIInputStream> mSynchronousInputStream;
nsCOMPtr<nsIDownloader> mDownloader;
nsCOMPtr<nsIRequest> mJarExtractionTransport;
#ifdef DEBUG
PRThread* mInitiator;
#if defined(PR_LOGGING)
nsCString mSpec;
#endif
nsCOMPtr<nsIJARURI> mJarURI;
nsCOMPtr<nsIURI> mOriginalURI;
nsCOMPtr<nsISupports> mOwner;
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsIProgressEventSink> mProgressSink;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsIStreamListener> mListener;
nsCOMPtr<nsISupports> mListenerContext;
nsCString mContentType;
nsCString mContentCharset;
PRInt32 mContentLength;
PRUint32 mLoadFlags;
nsresult mStatus;
PRBool mIsPending;
nsJARInputThunk *mJarInput;
nsCOMPtr<nsIInputStreamPump> mPump;
nsCOMPtr<nsIDownloader> mDownloader;
nsCOMPtr<nsIFile> mJarFile;
nsCOMPtr<nsIURI> mJarBaseURI;
nsCString mJarEntry;
};
#endif // nsJARChannel_h__

43
modules/libjar/nsJARProtocolHandler.cpp
Просмотреть файл

@ -52,12 +52,20 @@
static NS_DEFINE_CID(kZipReaderCacheCID, NS_ZIPREADERCACHE_CID);
#define NS_JAR_CACHE_SIZE 32
#define NS_JAR_CACHE_SIZE 32
////////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
nsJARProtocolHandler *gJarHandler = nsnull;
nsJARProtocolHandler::nsJARProtocolHandler()
{
gJarHandler = this;
}
nsJARProtocolHandler::~nsJARProtocolHandler()
{
gJarHandler = nsnull;
}
nsresult
@ -74,17 +82,13 @@ nsJARProtocolHandler::Init()
return rv;
}
nsIMIMEService*
nsJARProtocolHandler::GetCachedMimeService()
nsIMIMEService *
nsJARProtocolHandler::MimeService()
{
if (!mMimeService) {
if (!mMimeService)
mMimeService = do_GetService(NS_MIMESERVICE_CONTRACTID);
}
return mMimeService.get();
}
nsJARProtocolHandler::~nsJARProtocolHandler()
{
return mMimeService.get();
}
NS_IMPL_THREADSAFE_ISUPPORTS3(nsJARProtocolHandler,
@ -124,7 +128,7 @@ nsJARProtocolHandler::GetJARCache(nsIZipReaderCache* *result)
NS_IMETHODIMP
nsJARProtocolHandler::GetScheme(nsACString &result)
{
result = "jar";
result = NS_LITERAL_CSTRING("jar");
return NS_OK;
}
@ -185,21 +189,20 @@ nsJARProtocolHandler::NewURI(const nsACString &aSpec,
}
NS_IMETHODIMP
nsJARProtocolHandler::NewChannel(nsIURI* uri, nsIChannel* *result)
nsJARProtocolHandler::NewChannel(nsIURI *uri, nsIChannel **result)
{
nsresult rv;
nsJARChannel *chan = new nsJARChannel();
if (!chan)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(chan);
nsJARChannel* channel;
rv = nsJARChannel::Create(nsnull, NS_GET_IID(nsIJARChannel), (void**)&channel);
if (NS_FAILED(rv)) return rv;
rv = channel->Init(this, uri);
nsresult rv = chan->Init(uri);
if (NS_FAILED(rv)) {
NS_RELEASE(channel);
NS_RELEASE(chan);
return rv;
}
*result = channel;
*result = chan;
return NS_OK;
}

20
modules/libjar/nsJARProtocolHandler.h
Просмотреть файл

@ -35,8 +35,8 @@
*
* ***** END LICENSE BLOCK ***** */
#ifndef nsJARProtocolHandler_h___
#define nsJARProtocolHandler_h___
#ifndef nsJARProtocolHandler_h__
#define nsJARProtocolHandler_h__
#include "nsIJARProtocolHandler.h"
#include "nsIProtocolHandler.h"
@ -46,15 +46,6 @@
#include "nsWeakReference.h"
#include "nsCOMPtr.h"
#define NS_JARPROTOCOLHANDLER_CID \
{ /* 0xc7e410d4-0x85f2-11d3-9f63-006008a6efe9 */ \
0xc7e410d4, \
0x85f2, \
0x11d3, \
{0x9f, 0x63, 0x00, 0x60, 0x08, 0xa6, 0xef, 0xe9} \
}
class nsJARProtocolHandler : public nsIJARProtocolHandler
, public nsSupportsWeakReference
{
@ -73,11 +64,14 @@ public:
nsresult Init();
// returns non addref'ed pointer.
nsIMIMEService* GetCachedMimeService();
nsIMIMEService *MimeService();
nsIZipReaderCache *JarCache() { return mJARCache; }
protected:
nsCOMPtr<nsIZipReaderCache> mJARCache;
nsCOMPtr<nsIMIMEService> mMimeService;
};
#endif /* nsJARProtocolHandler_h___ */
extern nsJARProtocolHandler *gJarHandler;
#endif // !nsJARProtocolHandler_h__

8
modules/libjar/nsJARURI.h
Просмотреть файл

@ -24,14 +24,6 @@
#include "nsCOMPtr.h"
#include "nsString.h"
#define NS_JARURI_CID \
{ /* 0xc7e410d7-0x85f2-11d3-9f63-006008a6efe9 */ \
0xc7e410d7, \
0x85f2, \
0x11d3, \
{0x9f, 0x63, 0x00, 0x60, 0x08, 0xa6, 0xef, 0xe9} \
}
class nsJARURI : public nsIJARURI, nsISerializable
{
public:

2
modules/libpref/src/nsPrefService.cpp
Просмотреть файл

@ -43,8 +43,8 @@
#include "nsDirectoryServiceDefs.h"
#include "nsICategoryManager.h"
#include "nsCategoryManagerUtils.h"
#include "nsNetUtil.h"
#include "nsIFile.h"
#include "nsIFileStreams.h"
#include "nsILocalFile.h"
#include "nsIObserverService.h"
#include "nsPrefBranch.h"

2
netwerk/Makefile.in
Просмотреть файл

@ -29,11 +29,11 @@ include $(DEPTH)/config/autoconf.mk
DIRS = \
base \
cookie \
cache \
dns \
socket \
mime \
streamconv \
cache \
protocol \
build \
build2 \

14
netwerk/base/public/MANIFEST_IDL
Просмотреть файл

@ -2,15 +2,13 @@
# This is a list of local files which get copied to the mozilla:dist directory
#
nsIAuthenticator.idl
nsIAuthPrompt.idl
nsIChannel.idl
nsIDirectoryListing.idl
nsIDownloader.idl
nsIEncodedChannel.idl
nsIFileURL.idl
nsIFileChannel.idl
nsIFileTransportService.idl
nsIStreamTransportService.idl
nsIMIMEInputStream.idl
nsIPasswordManager.idl
nsIPasswordManagerInternal.idl
@ -22,12 +20,11 @@ nsIProxyInfo.idl
nsIProxy.idl
nsIRequest.idl
nsISocketTransportService.idl
nsIStreamIO.idl
nsIStreamIOChannel.idl
nsIStreamListener.idl
nsIStreamListenerProxy.idl
nsIStreamListenerTee.idl
nsIFileStreams.idl
nsIBufferedStreams.idl
nsITransport.idl
nsIStreamLoader.idl
nsIUnicharStreamLoader.idl
@ -37,18 +34,17 @@ nsIResumableEntityID.idl
nsIRequestObserver.idl
nsIRequestObserverProxy.idl
nsISimpleStreamListener.idl
nsISimpleStreamProvider.idl
nsIStreamProvider.idl
nsIStreamProviderProxy.idl
nsIUploadChannel.idl
nsIURI.idl
nsIURIChecker.idl
nsIURL.idl
nsIURLParser.idl
nsIStandardURL.idl
nsIWebFilters.idl
nsISecurityEventSink.idl
nsISecretDecoderRing.idl
nsISecureBrowserUI.idl
nsIByteRangeRequest.idl
nsIMultiPartChannel.idl
nsIInputStreamPump.idl
nsIInputStreamChannel.idl
nsIAsyncStreamCopier.idl

14
netwerk/base/public/Makefile.in
Просмотреть файл

@ -44,14 +44,15 @@ SDK_XPIDLSRCS = \
$(NULL)
XPIDLSRCS = \
nsIAuthenticator.idl \
nsIAuthPrompt.idl \
nsIAsyncStreamCopier.idl \
nsIBufferedStreams.idl \
nsIDirectoryListing.idl \
nsIDownloader.idl \
nsIEncodedChannel.idl \
nsIFileChannel.idl \
nsIFileStreams.idl \
nsIFileTransportService.idl \
nsIInputStreamPump.idl \
nsIInputStreamChannel.idl \
nsIMIMEInputStream.idl \
nsINetModRegEntry.idl \
nsINetModuleMgr.idl \
@ -68,23 +69,18 @@ XPIDLSRCS = \
nsITransport.idl \
nsISocketTransport.idl \
nsISocketTransportService.idl \
nsIStreamIO.idl \
nsIStreamIOChannel.idl \
nsIResumableChannel.idl \
nsIResumableEntityID.idl \
nsIRequestObserverProxy.idl \
nsIStreamListenerProxy.idl \
nsIStreamListenerTee.idl \
nsIStreamProvider.idl \
nsIStreamProviderProxy.idl \
nsISimpleStreamListener.idl \
nsISimpleStreamProvider.idl \
nsIStreamTransportService.idl \
nsIStreamLoader.idl \
nsIUnicharStreamLoader.idl \
nsIStandardURL.idl \
nsIURLParser.idl \
nsIURIChecker.idl \
nsIWebFilters.idl \
nsISecurityEventSink.idl \
nsISecretDecoderRing.idl \
nsISecureBrowserUI.idl \

2
netwerk/base/public/nsIFileChannel.idl
Просмотреть файл

@ -44,6 +44,8 @@ interface nsIFile;
* nsIFileChannel is an interface that allows for the initialization
* of a simple nsIChannel that is constructed from a single nsIFile and
* associated content type.
*
* XXX DEAD
*/
[scriptable, uuid(68a26506-f947-11d3-8cda-0060b0fc14a3)]
interface nsIFileChannel : nsIChannel

209
netwerk/base/public/nsIFileStreams.idl
Просмотреть файл

@ -37,7 +37,6 @@
#include "nsIInputStream.idl"
#include "nsIOutputStream.idl"
#include "nsISeekableStream.idl"
interface nsIFile;
@ -97,211 +96,3 @@ interface nsIFileOutputStream : nsIOutputStream
void init(in nsIFile file, in long ioFlags, in long perm,
in long behaviorFlags);
};
/**
* An input stream that reads ahead and keeps a buffer coming from another input
* stream so that fewer accesses to the underlying stream are necessary.
*/
[scriptable, uuid(616f5b48-da09-11d3-8cda-0060b0fc14a3)]
interface nsIBufferedInputStream : nsIInputStream
{
/**
* @param fillFromStream - add buffering to this stream
* @param bufferSize - specifies the maximum buffer size
*/
void init(in nsIInputStream fillFromStream,
in unsigned long bufferSize);
};
/**
* An output stream that stores up data to write out to another output stream
* and does the entire write only when the buffer is full, so that fewer writes
* to the underlying output stream are necessary.
*/
[scriptable, uuid(6476378a-da09-11d3-8cda-0060b0fc14a3)]
interface nsIBufferedOutputStream : nsIOutputStream
{
/**
* @param sinkToStream - add buffering to this stream
* @param bufferSize - specifies the maximum buffer size
*/
void init(in nsIOutputStream sinkToStream,
in unsigned long bufferSize);
};
%{C++
////////////////////////////////////////////////////////////////////////////////
#define NS_LOCALFILEINPUTSTREAM_CLASSNAME "Local File Input Stream"
#define NS_LOCALFILEINPUTSTREAM_CONTRACTID "@mozilla.org/network/file-input-stream;1"
#define NS_LOCALFILEINPUTSTREAM_CID \
{ /* be9a53ae-c7e9-11d3-8cda-0060b0fc14a3 */ \
0xbe9a53ae, \
0xc7e9, \
0x11d3, \
{0x8c, 0xda, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3} \
}
#define NS_LOCALFILEOUTPUTSTREAM_CLASSNAME "Local File Output Stream"
#define NS_LOCALFILEOUTPUTSTREAM_CONTRACTID "@mozilla.org/network/file-output-stream;1"
#define NS_LOCALFILEOUTPUTSTREAM_CID \
{ /* c272fee0-c7e9-11d3-8cda-0060b0fc14a3 */ \
0xc272fee0, \
0xc7e9, \
0x11d3, \
{0x8c, 0xda, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3} \
}
////////////////////////////////////////////////////////////////////////////////
#define NS_BUFFEREDINPUTSTREAM_CLASSNAME "Buffered Input Stream"
#define NS_BUFFEREDINPUTSTREAM_CONTRACTID "@mozilla.org/network/buffered-input-stream;1"
#define NS_BUFFEREDINPUTSTREAM_CID \
{ /* 9226888e-da08-11d3-8cda-0060b0fc14a3 */ \
0x9226888e, \
0xda08, \
0x11d3, \
{0x8c, 0xda, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3} \
}
#define NS_BUFFEREDOUTPUTSTREAM_CLASSNAME "Buffered Output Stream"
#define NS_BUFFEREDOUTPUTSTREAM_CONTRACTID "@mozilla.org/network/buffered-output-stream;1"
#define NS_BUFFEREDOUTPUTSTREAM_CID \
{ /* 9868b4ce-da08-11d3-8cda-0060b0fc14a3 */ \
0x9868b4ce, \
0xda08, \
0x11d3, \
{0x8c, 0xda, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3} \
}
////////////////////////////////////////////////////////////////////////////////
// move to nsNetUtil.h later...
#include "nsCOMPtr.h"
#include "nsIComponentManager.h"
#include "nsIFileChannel.h"
#include "nsIInputStream.h"
#include "nsIOutputStream.h"
#include "prio.h" // for read/write flags, permissions, etc.
// This will QI the file argument to an nsILocalFile in the Init method.
inline nsresult
NS_NewLocalFileChannel(nsIFileChannel** aResult,
nsIFile* aFile,
PRInt32 aIOFlags = -1,
PRInt32 aPerm = -1)
{
nsresult rv;
nsCOMPtr<nsIFileChannel> channel;
static NS_DEFINE_CID(kLocalFileChannelCID, NS_LOCALFILECHANNEL_CID);
rv = nsComponentManager::CreateInstance(kLocalFileChannelCID,
nsnull,
NS_GET_IID(nsIFileChannel),
getter_AddRefs(channel));
if (NS_FAILED(rv)) return rv;
rv = channel->Init(aFile, aIOFlags, aPerm);
if (NS_FAILED(rv)) return rv;
*aResult = channel;
NS_ADDREF(*aResult);
return NS_OK;
}
// This will QI the file argument to an nsILocalFile in the Init method.
inline nsresult
NS_NewLocalFileInputStream(nsIInputStream** aResult,
nsIFile* aFile,
PRInt32 aIOFlags = -1,
PRInt32 aPerm = -1,
PRInt32 aBehaviorFlags = 0)
{
nsresult rv;
nsCOMPtr<nsIFileInputStream> in;
static NS_DEFINE_CID(kLocalFileInputStreamCID, NS_LOCALFILEINPUTSTREAM_CID);
rv = nsComponentManager::CreateInstance(kLocalFileInputStreamCID,
nsnull,
NS_GET_IID(nsIFileInputStream),
getter_AddRefs(in));
if (NS_FAILED(rv)) return rv;
rv = in->Init(aFile, aIOFlags, aPerm, aBehaviorFlags);
if (NS_FAILED(rv)) return rv;
*aResult = in;
NS_ADDREF(*aResult);
return NS_OK;
}
// This will QI the file argument to an nsILocalFile in the Init method.
inline nsresult
NS_NewLocalFileOutputStream(nsIOutputStream** aResult,
nsIFile* aFile,
PRInt32 aIOFlags = -1,
PRInt32 aPerm = -1,
PRInt32 aBehaviorFlags = 0)
{
nsresult rv;
nsCOMPtr<nsIFileOutputStream> out;
static NS_DEFINE_CID(kLocalFileOutputStreamCID, NS_LOCALFILEOUTPUTSTREAM_CID);
rv = nsComponentManager::CreateInstance(kLocalFileOutputStreamCID,
nsnull,
NS_GET_IID(nsIFileOutputStream),
getter_AddRefs(out));
if (NS_FAILED(rv)) return rv;
rv = out->Init(aFile, aIOFlags, aPerm, aBehaviorFlags);
if (NS_FAILED(rv)) return rv;
*aResult = out;
NS_ADDREF(*aResult);
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
inline nsresult
NS_NewBufferedInputStream(nsIInputStream** aResult,
nsIInputStream* aStr,
PRUint32 aBufferSize)
{
nsresult rv;
nsCOMPtr<nsIBufferedInputStream> in;
static NS_DEFINE_CID(kBufferedInputStreamCID, NS_BUFFEREDINPUTSTREAM_CID);
rv = nsComponentManager::CreateInstance(kBufferedInputStreamCID,
nsnull,
NS_GET_IID(nsIBufferedInputStream),
getter_AddRefs(in));
if (NS_FAILED(rv)) return rv;
rv = in->Init(aStr, aBufferSize);
if (NS_FAILED(rv)) return rv;
*aResult = in;
NS_ADDREF(*aResult);
return NS_OK;
}
inline nsresult
NS_NewBufferedOutputStream(nsIOutputStream** aResult,
nsIOutputStream* aStr,
PRUint32 aBufferSize)
{
nsresult rv;
nsCOMPtr<nsIBufferedOutputStream> out;
static NS_DEFINE_CID(kBufferedOutputStreamCID, NS_BUFFEREDOUTPUTSTREAM_CID);
rv = nsComponentManager::CreateInstance(kBufferedOutputStreamCID,
nsnull,
NS_GET_IID(nsIBufferedOutputStream),
getter_AddRefs(out));
if (NS_FAILED(rv)) return rv;
rv = out->Init(aStr, aBufferSize);
if (NS_FAILED(rv)) return rv;
*aResult = out;
NS_ADDREF(*aResult);
return NS_OK;
}
%}

103
netwerk/base/public/nsISocketTransport.idl
Просмотреть файл

@ -37,59 +37,76 @@
#include "nsITransport.idl"
[scriptable, uuid(785CA0F0-C39E-11d3-9ED6-0010A4053FD0)]
interface nsIInterfaceRequestor;
interface nsISocketEventSink;
%{C++
#include "prio.h"
%}
[ptr] native PRNetAddrStar(PRNetAddr);
/**
* nsISocketTransport
*
* NOTE: This is a free-threaded interface.
*/
[scriptable, uuid(1e372001-ca12-4507-8405-3267d4e0c1fd)]
interface nsISocketTransport : nsITransport
{
/**
* Destination host and port. These are used for reporting status messages
* Since the end server may change at any time (eg persistent connections
* through proxies), a client can update this to get correct results.
* There is no other effect of setting these attributes, and if a proxy
* server is not being used, NS_ERROR_FAILURE is returned.
* Get the host for the underlying socket connection.
*/
attribute string host;
attribute long port;
readonly attribute AUTF8String host;
/**
* Get the port for the underlying socket connection.
*/
readonly attribute long port;
/**
* Get the PRNetAddr for the underlying socket connection.
*/
[noscript] void getAddress(in PRNetAddrStar addr);
/**
* Security info object returned from the PSM socket provider. This object
* supports nsISSLSocketControl, nsITransportSecurityInfo, and possibly
* other interfaces.
*/
readonly attribute nsISupports securityInfo;
/**
* Security notification callbacks passed to PSM via nsISSLSocketControl at
* socket creation time.
*
* NOTE: this attribute cannot be changed once a stream has been opened.
*/
attribute boolean reuseConnection;
attribute nsIInterfaceRequestor securityCallbacks;
/**
* socket read/write timeout in seconds; 0 = no timeout
* Test if this socket transport is (still) connected.
*/
attribute unsigned long socketTimeout;
boolean isAlive();
/**
* socket connect timeout in seconds; 0 = no timeout
* nsITransportEventSink status codes:
*/
attribute unsigned long socketConnectTimeout;
/**
* Is used to tell the channel to stop reading data after a certain point;
* needed by HTTP/1.1
*/
attribute long bytesExpected;
attribute unsigned long reuseCount;
/**
* Checks if the socket is still alive
*
* @param seconds amount of time after which the socket is always deemed to be
* dead (no further checking is done in this case); seconds = 0
* will cause it not to do the timeout checking at all
*/
boolean isAlive (in unsigned long seconds);
/**
* maximum amount of time in seconds the transport is allowed to stay alive
* while connected (0 - default; no maximum idle timeout)
*/
attribute unsigned long idleTimeout;
/**
* the string representation of the underlying ip address. Caller
* is responsible for de-allocating the returned string.
*/
[noscript] string GetIPStr(in unsigned long aStrLen);
const unsigned long STATUS_RESOLVING = 0x804b0003;
const unsigned long STATUS_CONNECTED_TO = 0x804b0004;
const unsigned long STATUS_SENDING_TO = 0x804b0005;
const unsigned long STATUS_RECEIVING_FROM = 0x804b0006;
const unsigned long STATUS_CONNECTING_TO = 0x804b0007;
const unsigned long STATUS_WAITING_FOR = 0x804b000a;
};
%{C++
/**
* #define's for compatibility
*/
#define NS_NET_STATUS_RESOLVING_HOST nsISocketTransport::STATUS_RESOLVING
#define NS_NET_STATUS_CONNECTED_TO nsISocketTransport::STATUS_CONNECTED_TO
#define NS_NET_STATUS_SENDING_TO nsISocketTransport::STATUS_SENDING_TO
#define NS_NET_STATUS_RECEIVING_FROM nsISocketTransport::STATUS_RECEIVING_FROM
#define NS_NET_STATUS_CONNECTING_TO nsISocketTransport::STATUS_CONNECTING_TO
%}

131
netwerk/base/public/nsISocketTransportService.idl
Просмотреть файл

@ -37,9 +37,8 @@
#include "nsISupports.idl"
interface nsITransport;
interface nsIEventSinkGetter;
interface nsIChannel;
interface nsISocketTransport;
interface nsISocketEventHandler;
interface nsIProxyInfo;
[scriptable, uuid(05331390-6884-11d3-9382-00104ba0fd40)]
@ -48,86 +47,70 @@ interface nsISocketTransportService : nsISupports
/**
* Creates a transport for a specified host and port.
*
* @param proxyInfo Information about any transport-layer proxying. Used
* for communicating information about proxies like socks.
* This can either be the proxyInfo attribute on an
* nsISupportsTransparentProxy (or from the protocolProxyService),
* or null for no proxying.
*
* @see nsISupportsTransparentProxy
* @param aSocketTypes
* array of socket type strings. null if using default socket type.
* @param aTypeCount
* specifies length of aSocketTypes.
* @param aHost
* specifies the target hostname or IP address literal of the peer
* for this socket.
* @param aPort
* specifies the target port of the peer for this socket.
* @param aProxyInfo
* specifies the transport-layer proxy type to use. null if no
* proxy. used for communicating information about proxies like
* SOCKS (which are transparent to upper protocols).
*
* @see nsIProxiedProtocolHandler
* @see nsIProtocolProxyService::GetProxyInfo
*/
nsITransport createTransport(in string host,
in long port,
in nsIProxyInfo proxyInfo,
in unsigned long bufferSegmentSize,
in unsigned long bufferMaxSize);
nsITransport createTransportOfType(in string socketType,
in string host,
in long port,
in nsIProxyInfo proxyInfo,
in unsigned long bufferSegmentSize,
in unsigned long bufferMaxSize);
nsITransport createTransportOfTypes(in unsigned long typeCount,
[array, size_is(typeCount)] in string socketTypes,
in string host,
in long port,
in nsIProxyInfo proxyInfo,
in unsigned long bufferSegmentSize,
in unsigned long bufferMaxSize);
nsISocketTransport createTransport([array, size_is(aTypeCount)]
in string aSocketTypes,
in unsigned long aTypeCount,
in AUTF8String aHost,
in long aPort,
in nsIProxyInfo aProxyInfo);
/**
* Returns true if the specified transport is good enough for
* being used again. The situations in which this may return false
* include- an error including server resets, an explicit
* Connection: close header (for HTTP) and timeouts!
* init/shutdown routines.
*/
boolean reuseTransport(in nsITransport i_Transport);
void init ();
void init();
void shutdown();
void wakeup (in nsITransport i_Transport);
/**
* Total number of nsSocketTransport objects currently alive
*/
readonly attribute unsigned long totalTransportCount;
/**
* A number of nsSocketTransport objects with I/O operation currently in-progress
*/
readonly attribute unsigned long inUseTransportCount;
/**
* A number of nsSocketTransport objects connected (this may include keep-alive idle connections)
*/
readonly attribute unsigned long connectedTransportCount;
/**
* Autodial helper is enabled via pref.
* Post an event to be executed on the socket thread.
*
* @param aHandler
* handler that will be executed on the socket thread.
* @param aType
* caller defined message parameter
* @param aUParam
* caller defined message parameter
* @param aVParam
* caller defined message parameter
*
* The socket transport service treats each parameter as opaque data (i.e.,
* it is not responsible for cleaning up aVParam if it happens to be
* dynamically allocated). If this function succeeds, then the message
* will be delivered. All messages successfully posted will be delivered
* before the socket transport service shuts down.
*/
[noscript] void postEvent(in nsISocketEventHandler aHandler,
in unsigned long aType,
in unsigned long aUParam,
in voidPtr aVParam);
/**
* controls whether or not the socket transport service should poke
* the autodialer on connection failure.
*/
attribute boolean autodialEnabled;
};
%{C++
#define NS_SOCKETTRANSPORTSERVICE_CID \
{ /* c07e81e0-ef12-11d2-92b6-00105a1b0d64 */ \
0xc07e81e0, \
0xef12, \
0x11d2, \
{0x92, 0xb6, 0x00, 0x10, 0x5a, 0x1b, 0x0d, 0x64} \
}
#include "nsNetError.h"
/**
* Status nsresult codes: used with nsIProgressEventSink::OnStatus
*/
#define NS_NET_STATUS_RESOLVING_HOST NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 3)
#define NS_NET_STATUS_CONNECTED_TO NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 4)
#define NS_NET_STATUS_SENDING_TO NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 5)
#define NS_NET_STATUS_RECEIVING_FROM NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 6)
#define NS_NET_STATUS_CONNECTING_TO NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 7)
%}
[uuid(c20f98be-b3e4-4f9b-a492-97a688577355)]
interface nsISocketEventHandler : nsISupports
{
[noscript] void onSocketEvent(in unsigned long aType,
in unsigned long aUParam,
in voidPtr aVParam);
};

2
netwerk/base/public/nsIStreamListenerProxy.idl
Просмотреть файл

@ -65,7 +65,7 @@ interface nsIStreamListenerProxy : nsIStreamListener
};
/**
* THIS INTERFACE IS DEPRACATED
* THIS INTERFACE IS DEPRECATED
*
* An asynchronous stream listener is used to ship data over to another thread specified
* by the thread's event queue. The receiver stream listener is then used to receive

165
netwerk/base/public/nsITransport.idl
Просмотреть файл

@ -1,147 +1,138 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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/
* The contents of this file are subject to the Mozilla 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/MPL/
*
* 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 Original Code is Mozilla.
*
* The Initial Developer of the Original Code is
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Darin Fisher <darin@netscape.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the NPL, indicate your
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the NPL, the GPL or the LGPL.
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsISupports.idl"
#include "nsIRequest.idl"
interface nsIStreamListener;
interface nsIStreamProvider;
interface nsIInputStream;
interface nsIOutputStream;
interface nsIInterfaceRequestor;
interface nsITransportEventSink;
interface nsIEventQueue;
[scriptable, uuid(fd01f9a4-d492-4cf8-b76e-160ffc8c01e8)]
[scriptable, uuid(cbb0baeb-5fcb-408b-a2be-9f8fc98d0af1)]
interface nsITransport : nsISupports
{
/**
* Get security info for this transport.
* Open flags.
*/
readonly attribute nsISupports securityInfo;
/**
* Get/set notificationCallbacks for this transport.
*/
nsIInterfaceRequestor getNotificationCallbacks();
void setNotificationCallbacks(in nsIInterfaceRequestor callbacks,
in unsigned long flags);
/**
* If the notificationCallbacks provide a nsIProgressEventSink
* implementation, then progress is by default reported to the thread
* that called setNotificationCallbacks. The following flags provide
* finer control over progress notifications:
*
* DONT_REPORT_PROGRESS - progress notifications are not sent.
* DONT_PROXY_PROGRESS - progress notifications can occur on any thread.
*/
const unsigned long DONT_REPORT_PROGRESS = 1;
const unsigned long DONT_PROXY_PROGRESS = 2;
const unsigned long OPEN_BLOCKING = 1<<0;
const unsigned long OPEN_UNBUFFERED = 1<<1;
/**
* Open an input stream on this transport.
*
* @param offset - read starting at this offset
* @param count - read this many bytes (pass PRUint32(-1) if unlimited)
* @param flags - optional transport specific flags
* @param aFlags
* optional transport specific flags.
* @param aSegmentSize
* if OPEN_UNBUFFERED is not set, then this parameter specifies the
* size of each buffer segment (pass 0 to use default value).
* @param aSegmentCount
* if OPEN_UNBUFFERED is not set, then this parameter specifies the
* maximum number of buffer segments (pass 0 to use default value).
*/
nsIInputStream openInputStream(in unsigned long offset,
in unsigned long count,
in unsigned long flags);
nsIInputStream openInputStream(in unsigned long aFlags,
in unsigned long aSegmentSize,
in unsigned long aSegmentCount);
/**
* Open an output stream on this transport.
*
* @param offset - write starting at this offset
* @param count - write no more than this many bytes (pass PRUint32(-1) if unlimited)
* @param flags - optional transport specific flags
* @param aFlags
* optional transport specific flags.
* @param aSegmentSize
* if OPEN_UNBUFFERED is not set, then this parameter specifies the
* size of each buffer segment (pass 0 to use default value).
* @param aSegmentCount
* if OPEN_UNBUFFERED is not set, then this parameter specifies the
* maximum number of buffer segments (pass 0 to use default value).
*/
nsIOutputStream openOutputStream(in unsigned long offset,
in unsigned long count,
in unsigned long flags);
nsIOutputStream openOutputStream(in unsigned long aFlags,
in unsigned long aSegmentSize,
in unsigned long aSegmentCount);
/**
* Asynchronously read data from the transport.
* Close the transport and any open streams.
*
* @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 (pass PRUint32(-1) if unlimited)
* @param flags - optional transport specific flags
* @param aReason
* the reason for closing the stream.
*/
nsIRequest asyncRead(in nsIStreamListener listener,
in nsISupports ctxt,
in unsigned long offset,
in unsigned long count,
in unsigned long flags);
void close(in nsresult aReason);
/**
* Asynchronously write data to the transport.
* Set the transport event sink.
*
* @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 no more than this many bytes (pass PRUint32(-1) if unlimited)
* @param flags - optional transport specific flags
* @param aSink
* receives transport layer notifications
* @param aEventQ
* indicates the event queue to which the notifications should
* be delivered. if NULL, then the notifications may occur on
* any thread. (NOTE: the event queue must be resolved.)
*/
nsIRequest asyncWrite(in nsIStreamProvider provider,
in nsISupports ctxt,
in unsigned long offset,
in unsigned long count,
in unsigned long flags);
void setEventSink(in nsITransportEventSink aSink,
in nsIEventQueue aEventQ);
/**
* Callbacks from asyncRead and asyncWrite may be proxied from a
* background thread (if one exists) to the thread which initiated
* the request. This is the expected behavior of such a nsITransport
* implementation. A caller of asyncRead or asyncWrite can explicitly
* ask the transport to not proxy the callback. The caller must then
* be prepared to handle callbacks on any thread.
* Generic nsITransportEventSink status codes. nsITransport
* implementations may override these status codes with their own more
* specific status codes (e.g., see nsISocketTransport).
*/
const unsigned long DONT_PROXY_OBSERVER = 1 << 0;
const unsigned long DONT_PROXY_LISTENER = 1 << 1;
const unsigned long DONT_PROXY_PROVIDER = 1 << 1;
const unsigned long STATUS_READING = 0x804b0008;
const unsigned long STATUS_WRITING = 0x804b0009;
};
[scriptable, uuid(d7abf5a4-ce72-482a-9217-a219a905c019)]
interface nsITransportRequest : nsIRequest
[scriptable, uuid(561de8af-1b74-4cd4-8479-89447d48185c)]
interface nsITransportEventSink : nsISupports
{
/**
* Get the transport associated with this request.
* Transport status notification.
*
* @param aTransport
* the transport sending this status notification.
* @param aStatus
* the transport status (resolvable to a string using
* nsIErrorService).
* @param aProgress
* the amount of data either read or written depending on the value
* of the status code. this value is relative to aProgressMax.
* @param aProgressMax
* the maximum amount of data that will be read or written. if
* unknown, 0xFFFFFFFF will be passed.
*/
readonly attribute nsITransport transport;
void onTransportStatus(in nsITransport aTransport,
in nsresult aStatus,
in unsigned long aProgress,
in unsigned long aProgressMax);
};

453
netwerk/base/public/nsNetUtil.h
Просмотреть файл

@ -38,47 +38,46 @@
#ifndef nsNetUtil_h__
#define nsNetUtil_h__
#include "nsString.h"
#include "nsNetError.h"
#include "nsNetCID.h"
#include "nsReadableUtils.h"
#include "netCore.h"
#include "nsString.h"
#include "nsMemory.h"
#include "nsCOMPtr.h"
#include "prio.h" // for read/write flags, permissions, etc.
#include "nsIURI.h"
#include "nsIInputStream.h"
#include "nsIOutputStream.h"
#include "nsIStreamListener.h"
#include "nsIStreamProvider.h"
#include "nsIRequestObserverProxy.h"
#include "nsIStreamListenerProxy.h"
#include "nsIStreamProviderProxy.h"
#include "nsIStreamListenerProxy.h" // XXX for nsIAsyncStreamListener
#include "nsISimpleStreamListener.h"
#include "nsISimpleStreamProvider.h"
#include "nsILoadGroup.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsIIOService.h"
#include "nsIServiceManager.h"
#include "nsIChannel.h"
#include "nsIStreamIOChannel.h"
#include "nsIInputStreamChannel.h"
#include "nsITransport.h"
#include "nsIHttpChannel.h"
#include "nsMemory.h"
#include "nsCOMPtr.h"
#include "nsIDownloader.h"
#include "nsIResumableEntityID.h"
#include "nsIStreamLoader.h"
#include "nsIUnicharStreamLoader.h"
#include "nsIStreamIO.h"
#include "nsIPipe.h"
#include "nsIProtocolHandler.h"
#include "nsIFileProtocolHandler.h"
#include "nsIStringStream.h"
#include "nsILocalFile.h"
#include "nsIFileStreams.h"
#include "nsXPIDLString.h"
#include "nsIProtocolProxyService.h"
#include "nsIProxyInfo.h"
#include "prio.h" // for read/write flags, permissions, etc.
#include "nsNetCID.h"
#include "nsIFileStreams.h"
#include "nsIBufferedStreams.h"
#include "nsIInputStreamPump.h"
#include "nsIAsyncStreamCopier.h"
// Helper, to simplify getting the I/O service.
inline const nsGetServiceByCID
@ -289,77 +288,79 @@ NS_MakeAbsoluteURI(nsAString &result,
}
inline nsresult
NS_NewPostDataStream(nsIInputStream **result,
PRBool isFile,
const nsACString &data,
PRUint32 encodeFlags,
nsIIOService* ioService = nsnull) // pass in nsIIOService to optimize callers
NS_NewInputStreamChannel(nsIChannel **result,
nsIURI *uri,
nsIInputStream *stream,
const nsACString &contentType = NS_LITERAL_CSTRING(""),
const nsACString &contentCharset = NS_LITERAL_CSTRING(""))
{
nsresult rv;
if (isFile) {
nsCOMPtr<nsILocalFile> file;
nsCOMPtr<nsIInputStream> fileStream;
rv = NS_NewNativeLocalFile(data, PR_FALSE, getter_AddRefs(file));
if (NS_FAILED(rv)) return rv;
rv = NS_NewLocalFileInputStream(getter_AddRefs(fileStream), file);
if (NS_FAILED(rv)) return rv;
// wrap the file stream with a buffered input stream
return NS_NewBufferedInputStream(result, fileStream, 8192);
}
// otherwise, create a string stream for the data
return NS_NewCStringInputStream(result, data);
}
inline nsresult
NS_NewStreamIOChannel(nsIStreamIOChannel **result,
nsIURI* uri,
nsIStreamIO* io)
{
nsresult rv;
nsCOMPtr<nsIStreamIOChannel> channel;
static NS_DEFINE_CID(kStreamIOChannelCID, NS_STREAMIOCHANNEL_CID);
rv = nsComponentManager::CreateInstance(kStreamIOChannelCID,
nsnull,
NS_GET_IID(nsIStreamIOChannel),
getter_AddRefs(channel));
if (NS_FAILED(rv)) return rv;
rv = channel->Init(uri, io);
static NS_DEFINE_CID(kInputStreamChannelCID, NS_INPUTSTREAMCHANNEL_CID);
nsCOMPtr<nsIInputStreamChannel> channel =
do_CreateInstance(kInputStreamChannelCID, &rv);
if (NS_FAILED(rv)) return rv;
*result = channel;
NS_ADDREF(*result);
rv = channel->SetURI(uri);
if (NS_FAILED(rv)) return rv;
rv = channel->SetContentStream(stream);
if (NS_FAILED(rv)) return rv;
rv = channel->SetContentType(contentType);
if (NS_FAILED(rv)) return rv;
rv = channel->SetContentCharset(contentCharset);
if (NS_FAILED(rv)) return rv;
NS_ADDREF(*result = channel);
return NS_OK;
}
inline nsresult
NS_NewInputStreamChannel(nsIChannel **result,
nsIURI* uri,
nsIInputStream* inStr,
const nsACString &contentType,
const nsACString &contentCharset,
PRInt32 contentLength)
NS_NewInputStreamPump(nsIInputStreamPump **result,
nsIInputStream *stream,
PRInt32 streamPos = -1,
PRInt32 streamLen = -1,
PRUint32 segsize = 0,
PRUint32 segcount = 0,
PRBool closeWhenDone = PR_FALSE)
{
nsresult rv;
nsCAutoString spec;
rv = uri->GetSpec(spec);
static NS_DEFINE_CID(kInputStreamPumpCID, NS_INPUTSTREAMPUMP_CID);
nsCOMPtr<nsIInputStreamPump> pump =
do_CreateInstance(kInputStreamPumpCID, &rv);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIInputStreamIO> io;
rv = NS_NewInputStreamIO(getter_AddRefs(io), spec, inStr,
contentType, contentCharset, contentLength);
rv = pump->Init(stream, streamPos, streamLen,
segsize, segcount, closeWhenDone);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIStreamIOChannel> channel;
rv = NS_NewStreamIOChannel(getter_AddRefs(channel), uri, io);
NS_ADDREF(*result = pump);
return NS_OK;
}
// NOTE: you can optimize the copy by specifying whether or not your streams
// are buffered (i.e., do they implement ReadSegments/WriteSegments). the
// default assumption of FALSE for both streams is OK, but the copy is much
// more efficient if one of the streams is buffered.
inline nsresult
NS_NewAsyncStreamCopier(nsIAsyncStreamCopier **result,
nsIInputStream *source,
nsIOutputStream *sink,
PRBool sourceBuffered = PR_FALSE,
PRBool sinkBuffered = PR_FALSE,
PRUint32 chunkSize = 0)
{
nsresult rv;
static NS_DEFINE_CID(kAsyncStreamCopierCID, NS_ASYNCSTREAMCOPIER_CID);
nsCOMPtr<nsIAsyncStreamCopier> copier =
do_CreateInstance(kAsyncStreamCopierCID, &rv);
if (NS_FAILED(rv)) return rv;
*result = channel;
NS_ADDREF(*result);
rv = copier->Init(source, sink, sourceBuffered, sinkBuffered, chunkSize);
if (NS_FAILED(rv)) return rv;
NS_ADDREF(*result = copier);
return NS_OK;
}
@ -505,58 +506,6 @@ NS_NewRequestObserverProxy(nsIRequestObserver **aResult,
return CallQueryInterface(proxy, aResult);
}
inline nsresult
NS_NewStreamListenerProxy(nsIStreamListener **aResult,
nsIStreamListener *aListener,
nsIEventQueue *aEventQ=nsnull,
PRUint32 aBufferSegmentSize=0,
PRUint32 aBufferMaxSize=0)
{
NS_ENSURE_ARG_POINTER(aResult);
nsresult rv;
nsCOMPtr<nsIStreamListenerProxy> proxy;
static NS_DEFINE_CID(kStreamListenerProxyCID, NS_STREAMLISTENERPROXY_CID);
rv = nsComponentManager::CreateInstance(kStreamListenerProxyCID,
nsnull,
NS_GET_IID(nsIStreamListenerProxy),
getter_AddRefs(proxy));
if (NS_FAILED(rv)) return rv;
rv = proxy->Init(aListener, aEventQ, aBufferSegmentSize, aBufferMaxSize);
if (NS_FAILED(rv)) return rv;
NS_ADDREF(*aResult = proxy);
return NS_OK;
}
inline nsresult
NS_NewStreamProviderProxy(nsIStreamProvider **aResult,
nsIStreamProvider *aProvider,
nsIEventQueue *aEventQ=nsnull,
PRUint32 aBufferSegmentSize=0,
PRUint32 aBufferMaxSize=0)
{
NS_ENSURE_ARG_POINTER(aResult);
nsresult rv;
nsCOMPtr<nsIStreamProviderProxy> proxy;
static NS_DEFINE_CID(kStreamProviderProxyCID, NS_STREAMPROVIDERPROXY_CID);
rv = nsComponentManager::CreateInstance(kStreamProviderProxyCID,
nsnull,
NS_GET_IID(nsIStreamProviderProxy),
getter_AddRefs(proxy));
if (NS_FAILED(rv)) return rv;
rv = proxy->Init(aProvider, aEventQ, aBufferSegmentSize, aBufferMaxSize);
if (NS_FAILED(rv)) return rv;
NS_ADDREF(*aResult = proxy);
return NS_OK;
}
inline nsresult
NS_NewSimpleStreamListener(nsIStreamListener **aResult,
nsIOutputStream *aSink,
@ -580,53 +529,7 @@ NS_NewSimpleStreamListener(nsIStreamListener **aResult,
return NS_OK;
}
inline nsresult
NS_NewSimpleStreamProvider(nsIStreamProvider **aResult,
nsIInputStream *aSource,
nsIRequestObserver *aObserver=nsnull)
{
NS_ENSURE_ARG_POINTER(aResult);
nsresult rv;
nsCOMPtr<nsISimpleStreamProvider> provider;
static NS_DEFINE_CID(kSimpleStreamProviderCID, NS_SIMPLESTREAMPROVIDER_CID);
rv = nsComponentManager::CreateInstance(kSimpleStreamProviderCID,
nsnull,
NS_GET_IID(nsISimpleStreamProvider),
getter_AddRefs(provider));
if (NS_FAILED(rv)) return rv;
rv = provider->Init(aSource, aObserver);
if (NS_FAILED(rv)) return rv;
NS_ADDREF(*aResult = provider);
return NS_OK;
}
/*
// Depracated, prefer NS_NewStreamObserverProxy
inline nsresult
NS_NewAsyncStreamObserver(nsIRequestObserver **result,
nsIRequestObserver *receiver,
nsIEventQueue *eventQueue)
{
nsresult rv;
nsCOMPtr<nsIAsyncStreamObserver> obs;
static NS_DEFINE_CID(kAsyncStreamObserverCID, NS_ASYNCSTREAMOBSERVER_CID);
rv = nsComponentManager::CreateInstance(kAsyncStreamObserverCID,
nsnull,
NS_GET_IID(nsIAsyncStreamObserver),
getter_AddRefs(obs));
if (NS_FAILED(rv)) return rv;
rv = obs->Init(receiver, eventQueue);
if (NS_FAILED(rv)) return rv;
NS_ADDREF(*result = obs);
return NS_OK;
}
*/
// Depracated, prefer NS_NewStreamListenerProxy
// Deprecated, prefer NS_NewStreamListenerProxy
inline nsresult
NS_NewAsyncStreamListener(nsIStreamListener **result,
nsIStreamListener *receiver,
@ -647,106 +550,6 @@ NS_NewAsyncStreamListener(nsIStreamListener **result,
return NS_OK;
}
// Depracated, prefer a true synchonous implementation
inline nsresult
NS_NewSyncStreamListener(nsIInputStream **aInStream,
nsIOutputStream **aOutStream,
nsIStreamListener **aResult)
{
nsresult rv;
NS_ENSURE_ARG_POINTER(aInStream);
NS_ENSURE_ARG_POINTER(aOutStream);
nsCOMPtr<nsIInputStream> pipeIn;
nsCOMPtr<nsIOutputStream> pipeOut;
rv = NS_NewPipe(getter_AddRefs(pipeIn),
getter_AddRefs(pipeOut),
4*1024, // NS_SYNC_STREAM_LISTENER_SEGMENT_SIZE
32*1024); // NS_SYNC_STREAM_LISTENER_BUFFER_SIZE
if (NS_FAILED(rv)) return rv;
rv = NS_NewSimpleStreamListener(aResult, pipeOut);
if (NS_FAILED(rv)) return rv;
NS_ADDREF(*aInStream = pipeIn);
NS_ADDREF(*aOutStream = pipeOut);
return NS_OK;
}
//
// Calls AsyncWrite on the specified transport, with a stream provider that
// reads data from the specified input stream.
//
inline nsresult
NS_AsyncWriteFromStream(nsIRequest **aRequest,
nsITransport *aTransport,
nsIInputStream *aSource,
PRUint32 aOffset=0,
PRUint32 aCount=0,
PRUint32 aFlags=0,
nsIRequestObserver *aObserver=NULL,
nsISupports *aContext=NULL)
{
NS_ENSURE_ARG_POINTER(aTransport);
nsresult rv;
nsCOMPtr<nsIStreamProvider> provider;
rv = NS_NewSimpleStreamProvider(getter_AddRefs(provider),
aSource,
aObserver);
if (NS_FAILED(rv)) return rv;
//
// We can safely allow the transport impl to bypass proxying the provider
// since we are using a simple stream provider.
//
// A simple stream provider masks the OnDataWritable from consumers.
// Moreover, it makes an assumption about the underlying nsIInputStream
// implementation: namely, that it is thread-safe and blocking.
//
// So, let's always make this optimization.
//
aFlags |= nsITransport::DONT_PROXY_PROVIDER;
return aTransport->AsyncWrite(provider, aContext,
aOffset,
aCount,
aFlags,
aRequest);
}
//
// Calls AsyncRead on the specified transport, with a stream listener that
// writes data to the specified output stream.
//
inline nsresult
NS_AsyncReadToStream(nsIRequest **aRequest,
nsITransport *aTransport,
nsIOutputStream *aSink,
PRUint32 aOffset=0,
PRUint32 aCount=0,
PRUint32 aFlags=0,
nsIRequestObserver *aObserver=NULL,
nsISupports *aContext=NULL)
{
NS_ENSURE_ARG_POINTER(aTransport);
nsresult rv;
nsCOMPtr<nsIStreamListener> listener;
rv = NS_NewSimpleStreamListener(getter_AddRefs(listener),
aSink,
aObserver);
if (NS_FAILED(rv)) return rv;
return aTransport->AsyncRead(listener, aContext,
aOffset,
aCount,
aFlags,
aRequest);
}
inline nsresult
NS_CheckPortSafety(PRInt32 port, const char* scheme, nsIIOService* ioService = nsnull)
{
@ -903,5 +706,119 @@ NS_ParseContentType(const nsACString &rawContentType,
return NS_OK;
}
#endif // nsNetUtil_h__
inline nsresult
NS_NewLocalFileInputStream(nsIInputStream** aResult,
nsIFile* aFile,
PRInt32 aIOFlags = -1,
PRInt32 aPerm = -1,
PRInt32 aBehaviorFlags = 0)
{
nsresult rv;
nsCOMPtr<nsIFileInputStream> in;
static NS_DEFINE_CID(kLocalFileInputStreamCID, NS_LOCALFILEINPUTSTREAM_CID);
rv = nsComponentManager::CreateInstance(kLocalFileInputStreamCID,
nsnull,
NS_GET_IID(nsIFileInputStream),
getter_AddRefs(in));
if (NS_FAILED(rv)) return rv;
rv = in->Init(aFile, aIOFlags, aPerm, aBehaviorFlags);
if (NS_FAILED(rv)) return rv;
*aResult = in;
NS_ADDREF(*aResult);
return NS_OK;
}
inline nsresult
NS_NewLocalFileOutputStream(nsIOutputStream** aResult,
nsIFile* aFile,
PRInt32 aIOFlags = -1,
PRInt32 aPerm = -1,
PRInt32 aBehaviorFlags = 0)
{
nsresult rv;
nsCOMPtr<nsIFileOutputStream> out;
static NS_DEFINE_CID(kLocalFileOutputStreamCID, NS_LOCALFILEOUTPUTSTREAM_CID);
rv = nsComponentManager::CreateInstance(kLocalFileOutputStreamCID,
nsnull,
NS_GET_IID(nsIFileOutputStream),
getter_AddRefs(out));
if (NS_FAILED(rv)) return rv;
rv = out->Init(aFile, aIOFlags, aPerm, aBehaviorFlags);
if (NS_FAILED(rv)) return rv;
*aResult = out;
NS_ADDREF(*aResult);
return NS_OK;
}
inline nsresult
NS_NewBufferedInputStream(nsIInputStream** aResult,
nsIInputStream* aStr,
PRUint32 aBufferSize)
{
nsresult rv;
nsCOMPtr<nsIBufferedInputStream> in;
static NS_DEFINE_CID(kBufferedInputStreamCID, NS_BUFFEREDINPUTSTREAM_CID);
rv = nsComponentManager::CreateInstance(kBufferedInputStreamCID,
nsnull,
NS_GET_IID(nsIBufferedInputStream),
getter_AddRefs(in));
if (NS_FAILED(rv)) return rv;
rv = in->Init(aStr, aBufferSize);
if (NS_FAILED(rv)) return rv;
*aResult = in;
NS_ADDREF(*aResult);
return NS_OK;
}
inline nsresult
NS_NewBufferedOutputStream(nsIOutputStream** aResult,
nsIOutputStream* aStr,
PRUint32 aBufferSize)
{
nsresult rv;
nsCOMPtr<nsIBufferedOutputStream> out;
static NS_DEFINE_CID(kBufferedOutputStreamCID, NS_BUFFEREDOUTPUTSTREAM_CID);
rv = nsComponentManager::CreateInstance(kBufferedOutputStreamCID,
nsnull,
NS_GET_IID(nsIBufferedOutputStream),
getter_AddRefs(out));
if (NS_FAILED(rv)) return rv;
rv = out->Init(aStr, aBufferSize);
if (NS_FAILED(rv)) return rv;
*aResult = out;
NS_ADDREF(*aResult);
return NS_OK;
}
inline nsresult
NS_NewPostDataStream(nsIInputStream **result,
PRBool isFile,
const nsACString &data,
PRUint32 encodeFlags,
nsIIOService* ioService = nsnull) // pass in nsIIOService to optimize callers
{
nsresult rv;
if (isFile) {
nsCOMPtr<nsILocalFile> file;
nsCOMPtr<nsIInputStream> fileStream;
rv = NS_NewNativeLocalFile(data, PR_FALSE, getter_AddRefs(file));
if (NS_FAILED(rv)) return rv;
rv = NS_NewLocalFileInputStream(getter_AddRefs(fileStream), file);
if (NS_FAILED(rv)) return rv;
// wrap the file stream with a buffered input stream
return NS_NewBufferedInputStream(result, fileStream, 8192);
}
// otherwise, create a string stream for the data
return NS_NewCStringInputStream(result, data);
}
#endif // nsNetUtil_h__

13
netwerk/base/src/Makefile.in
Просмотреть файл

@ -39,14 +39,15 @@ REQUIRES = xpcom \
$(NULL)
CPPSRCS = \
nsAsyncStreamCopier.cpp \
nsAsyncStreamListener.cpp \
nsBufferedStreams.cpp \
nsDirectoryIndexStream.cpp \
nsDownloader.cpp \
nsFileStreams.cpp \
nsFileTransport.cpp \
nsFileTransportService.cpp \
nsInputStreamChannel.cpp \
nsInputStreamPump.cpp \
nsStreamTransportService.cpp \
nsIOService.cpp \
nsLoadGroup.cpp \
nsMIMEInputStream.cpp \
@ -56,17 +57,13 @@ CPPSRCS = \
nsRequestObserverProxy.cpp \
nsResumableEntityID.cpp \
nsSimpleStreamListener.cpp \
nsSimpleStreamProvider.cpp \
nsSimpleURI.cpp \
nsStandardURL.cpp \
nsSocketTransport.cpp \
nsSocketTransportService.cpp \
nsStorageTransport.cpp \
nsStreamListenerProxy.cpp \
nsSocketTransport2.cpp \
nsSocketTransportService2.cpp \
nsStreamListenerTee.cpp \
nsStreamLoader.cpp \
nsUnicharStreamLoader.cpp \
nsStreamProviderProxy.cpp \
nsURIChecker.cpp \
nsURLHelper.cpp \
nsURLParsers.cpp \

3
netwerk/base/src/nsBufferedStreams.h
Просмотреть файл

@ -38,9 +38,10 @@
#ifndef nsBufferedStreams_h__
#define nsBufferedStreams_h__
#include "nsIFileStreams.h"
#include "nsIBufferedStreams.h"
#include "nsIInputStream.h"
#include "nsIOutputStream.h"
#include "nsISeekableStream.h"
#include "nsIStreamBufferAccess.h"
#include "nsCOMPtr.h"

71
netwerk/base/src/nsDownloader.cpp
Просмотреть файл

@ -44,55 +44,60 @@
#include "nsICachingChannel.h"
#include "nsProxiedService.h"
#include "nsIFile.h"
#include "nsIFileURL.h"
#include "nsXPIDLString.h"
static NS_DEFINE_CID(kProxyObjectManagerCID, NS_PROXYEVENT_MANAGER_CID);
// XXX this API seems all wrong for "sync" downloading
NS_IMETHODIMP
nsDownloader::Init(nsIURI* aURL,
nsIDownloadObserver* aObserver,
nsISupports* aContext,
PRBool aIsSynchronous,
nsILoadGroup* aGroup,
nsIInterfaceRequestor* aNotificationCallbacks,
nsLoadFlags aLoadAttributes)
nsIInterfaceRequestor* aCallbacks,
nsLoadFlags aLoadFlags)
{
NS_ENSURE_ARG_POINTER(aObserver);
nsresult rv;
mObserver = aObserver;
mContext = aContext;
nsCOMPtr<nsIFile> localFile;
nsCOMPtr<nsIChannel> channel;
rv = NS_NewChannel(getter_AddRefs(channel), aURL, nsnull, aGroup, aNotificationCallbacks,
aLoadAttributes);
if (NS_SUCCEEDED(rv) && channel)
{
nsCOMPtr<nsIFileChannel> fc = do_QueryInterface(channel);
if (fc)
rv = fc->GetFile(getter_AddRefs(localFile));
}
if (mObserver && (NS_FAILED(rv) || localFile))
{
if (aIsSynchronous)
return mObserver->OnDownloadComplete(this, mContext, rv, localFile);
else
{
// If the open failed or the file is local, call the observer.
// don't callback synchronously as it puts the caller
// in a recursive situation and breaks the asynchronous
// semantics of nsIDownloader
nsresult rv2 = NS_OK;
nsCOMPtr<nsIProxyObjectManager> pIProxyObjectManager =
do_GetService(kProxyObjectManagerCID, &rv);
if (NS_FAILED(rv2)) return rv2;
nsCOMPtr<nsIDownloadObserver> pObserver;
rv2 = pIProxyObjectManager->GetProxyForObject(NS_CURRENT_EVENTQ,
NS_GET_IID(nsIDownloadObserver), mObserver,
PROXY_ASYNC | PROXY_ALWAYS, getter_AddRefs(pObserver));
if (NS_FAILED(rv2)) return rv2;
return pObserver->OnDownloadComplete(this, mContext, rv, localFile);
}
nsCOMPtr<nsIFile> file;
nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(aURL);
if (fileURL)
fileURL->GetFile(getter_AddRefs(file));
if (file) {
if (aIsSynchronous)
return mObserver->OnDownloadComplete(this, mContext, rv, file);
// If the open failed or the file is local, call the observer.
// don't callback synchronously as it puts the caller
// in a recursive situation and breaks the asynchronous
// semantics of nsIDownloader
nsCOMPtr<nsIProxyObjectManager> pIProxyObjectManager =
do_GetService(kProxyObjectManagerCID, &rv);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIDownloadObserver> pObserver;
rv = pIProxyObjectManager->GetProxyForObject(NS_CURRENT_EVENTQ,
NS_GET_IID(nsIDownloadObserver), mObserver,
PROXY_ASYNC | PROXY_ALWAYS, getter_AddRefs(pObserver));
if (NS_FAILED(rv)) return rv;
return pObserver->OnDownloadComplete(this, mContext, NS_OK, file);
}
nsCOMPtr<nsIChannel> channel;
rv = NS_NewChannel(getter_AddRefs(channel), aURL, nsnull,
aGroup, aCallbacks, aLoadFlags);
if (NS_FAILED(rv)) return rv;
return channel->AsyncOpen(this, aContext);
}

305
netwerk/base/src/nsFileStreams.cpp
Просмотреть файл

@ -71,7 +71,8 @@
#include "nsDirectoryIndexStream.h"
#include "nsMimeTypes.h"
#include "nsReadLine.h"
#include "nsFileTransportService.h"
#include "nsNetUtil.h"
//#include "nsFileTransportService.h"
#define NS_NO_INPUT_BUFFERING 1 // see http://bugzilla.mozilla.org/show_bug.cgi?id=41067
@ -91,308 +92,6 @@ PRLogModuleInfo* gFileIOLog = nsnull;
#endif /* PR_LOGGING */
////////////////////////////////////////////////////////////////////////////////
// nsFileIO
#define NS_INPUT_STREAM_BUFFER_SIZE (16 * 1024)
#define NS_OUTPUT_STREAM_BUFFER_SIZE (64 * 1024)
NS_IMPL_THREADSAFE_ISUPPORTS2(nsFileIO,
nsIFileIO,
nsIStreamIO)
nsFileIO::nsFileIO()
: mFD(0),
mIOFlags(0),
mPerm(0),
mStatus(NS_OK)
{
#if defined(PR_LOGGING)
//
// Initialize the global PRLogModule for socket transport logging
// if necessary...
//
if (nsnull == gFileIOLog) {
gFileIOLog = PR_NewLogModule("nsFileIO");
}
#endif /* PR_LOGGING */
}
nsFileIO::~nsFileIO()
{
(void)Close(NS_OK);
if (mFD) {
PR_Close(mFD);
mFD = nsnull;
}
}
NS_METHOD
nsFileIO::Create(nsISupports *aOuter, REFNSIID aIID, void **aResult)
{
if (aOuter)
return NS_ERROR_NO_AGGREGATION;
nsFileIO* io = new nsFileIO();
if (io == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(io);
nsresult rv = io->QueryInterface(aIID, aResult);
NS_RELEASE(io);
return rv;
}
NS_IMETHODIMP
nsFileIO::Init(nsIFile* file, PRInt32 ioFlags, PRInt32 perm)
{
NS_ASSERTION(file, "File must not be null");
if (file == nsnull)
return NS_ERROR_NOT_INITIALIZED;
mFile = file;
mIOFlags = ioFlags;
mPerm = perm;
#ifdef PR_LOGGING
nsresult rv = mFile->GetNativePath(mSpec);
NS_ASSERTION(NS_SUCCEEDED(rv), "GetSpec failed");
#endif
return NS_OK;
}
NS_IMETHODIMP
nsFileIO::GetFile(nsIFile* *aFile)
{
*aFile = mFile;
NS_ADDREF(*aFile);
return NS_OK;
}
NS_IMETHODIMP
nsFileIO::Open()
{
NS_ASSERTION(mFile, "File must not be null");
if (mFile == nsnull)
return NS_ERROR_NOT_INITIALIZED;
nsresult rv = NS_OK;
nsCOMPtr<nsILocalFile> localFile = do_QueryInterface(mFile, &rv);
if (NS_FAILED(rv)) return rv;
if (mIOFlags == -1)
mIOFlags = PR_RDONLY;
if (mPerm == -1)
mPerm = 0;
rv = localFile->OpenNSPRFileDesc(mIOFlags, mPerm, &mFD);
if (NS_FAILED(rv)) {
mFD = nsnull; // just in case
#ifdef PR_LOGGING
nsresult openError = rv;
#endif
// maybe we can't open this because it is a directory...
PRBool isDir;
rv = localFile->IsDirectory(&isDir);
if (NS_SUCCEEDED(rv) && isDir) {
return NS_OK;
}
PR_LOG(gFileIOLog, PR_LOG_DEBUG,
("nsFileIO: OpenNSPRFileDesc failed [rv=%x]\n", openError));
return NS_ERROR_FILE_NOT_FOUND;
}
PR_LOG(gFileIOLog, PR_LOG_DEBUG,
("nsFileIO: logically opening %s", mSpec.get()));
return rv;
}
NS_IMETHODIMP
nsFileIO::GetContentType(nsACString &result)
{
if (!mContentType.IsEmpty()) {
result = mContentType;
return NS_OK;
}
if (mFile == nsnull)
return NS_ERROR_NOT_INITIALIZED;
nsresult rv = NS_OK;
nsIMIMEService* mimeServ = nsnull;
nsFileTransportService* fileTransportService = nsFileTransportService::GetInstance();
if (fileTransportService) {
mimeServ = fileTransportService->GetCachedMimeService();
if (mimeServ) {
nsXPIDLCString mimeType; // XXX fix mime service to use |ACString|
rv = mimeServ->GetTypeFromFile(mFile, getter_Copies(mimeType));
if (NS_SUCCEEDED(rv))
result = mimeType;
}
}
if (!mimeServ || (NS_FAILED(rv))) {
// if all else fails treat it as text/html?
result = NS_LITERAL_CSTRING(UNKNOWN_CONTENT_TYPE);
}
mContentType = result;
return NS_OK;
}
NS_IMETHODIMP
nsFileIO::GetContentCharset(nsACString &result)
{
result.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsFileIO::GetContentLength(PRInt32 *result)
{
NS_ENSURE_ARG_POINTER(result);
*result = -1;
if (!mFile)
return NS_ERROR_NOT_INITIALIZED;
// We'll try to use the file's length, if it has one. If not,
// assume the file to be special, and set the content length
// to -1, which means "read the stream until exhausted".
PRInt64 size;
nsresult rv = mFile->GetFileSize(&size);
if (NS_SUCCEEDED(rv)) {
*result = nsInt64(size);
if (*result == 0)
*result = -1;
}
return rv;
}
NS_IMETHODIMP
nsFileIO::Close(nsresult status)
{
if (mFile) {
PR_LOG(gFileIOLog, PR_LOG_DEBUG,
("nsFileIO: logically closing %s: status=%x",
mSpec.get(), status));
mFile = nsnull;
}
mStatus = status;
return NS_OK;
}
NS_IMETHODIMP
nsFileIO::GetInputStream(nsIInputStream * *aInputStream)
{
NS_ASSERTION(mFile, "File must not be null");
if (!mFile)
return NS_ERROR_NOT_INITIALIZED;
nsresult rv;
if (!mFD) {
rv = Open();
if (NS_FAILED(rv)) // file or directory does not exist
return rv;
}
PRBool isDir;
rv = mFile->IsDirectory(&isDir);
if (NS_FAILED(rv)) // file or directory does not exist
return rv;
if (isDir) {
if (mFD) {
PR_Close(mFD);
mFD = nsnull;
}
rv = nsDirectoryIndexStream::Create(mFile, aInputStream);
PR_LOG(gFileIOLog, PR_LOG_DEBUG,
("nsFileIO: opening local dir %s for input (%x)",
mSpec.get(), rv));
return rv;
}
nsFileInputStream* fileIn = new nsFileInputStream();
if (fileIn == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(fileIn);
rv = fileIn->InitWithFileDescriptor(mFD, this);
if (NS_SUCCEEDED(rv)) {
#ifdef NS_NO_INPUT_BUFFERING
*aInputStream = fileIn;
NS_ADDREF(*aInputStream);
#else
rv = NS_NewBufferedInputStream(aInputStream,
fileIn,
NS_INPUT_STREAM_BUFFER_SIZE);
#endif
}
NS_RELEASE(fileIn);
PR_LOG(gFileIOLog, PR_LOG_DEBUG,
("nsFileIO: opening local file %s for input (%x)",
mSpec.get(), rv));
return rv;
}
NS_IMETHODIMP
nsFileIO::GetOutputStream(nsIOutputStream * *aOutputStream)
{
NS_ASSERTION(mFile, "File must not be null");
if (mFile == nsnull)
return NS_ERROR_NOT_INITIALIZED;
nsresult rv;
if (!mFD) {
rv = Open();
if (NS_FAILED(rv)) // file or directory does not exist
return rv;
}
PRBool isDir;
rv = mFile->IsDirectory(&isDir);
if (NS_SUCCEEDED(rv) && isDir) {
return NS_ERROR_FAILURE;
}
nsFileOutputStream* fileOut = new nsFileOutputStream();
if (fileOut == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(fileOut);
rv = fileOut->InitWithFileDescriptor(mFD, this);
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIOutputStream> bufStr;
#ifdef NS_NO_OUTPUT_BUFFERING
*aOutputStream = fileOut;
NS_ADDREF(*aOutputStream);
#else
rv = NS_NewBufferedOutputStream(aOutputStream,
fileOut,
NS_OUTPUT_STREAM_BUFFER_SIZE);
#endif
}
NS_RELEASE(fileOut);
PR_LOG(gFileIOLog, PR_LOG_DEBUG,
("nsFileIO: opening local file %s for output (%x)",
mSpec.get(), rv));
return rv;
}
NS_IMETHODIMP
nsFileIO::GetName(nsACString &aName)
{
NS_ASSERTION(mFile, "File must not be null");
if (mFile == nsnull)
return NS_ERROR_NOT_INITIALIZED;
nsAutoString path;
nsresult rv = mFile->GetPath(path);
if (NS_FAILED(rv)) return rv;
aName = NS_ConvertUCS2toUTF8(path);
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsFileStream

30
netwerk/base/src/nsFileStreams.h
Просмотреть файл

@ -40,44 +40,16 @@
#include "nsIFileStreams.h"
#include "nsIFile.h"
#include "nsIChannel.h"
#include "nsIInputStream.h"
#include "nsIOutputStream.h"
#include "nsISeekableStream.h"
#include "nsILineInputStream.h"
#include "nsIStreamIO.h"
#include "nsCOMPtr.h"
#include "nsReadLine.h"
#include "prlog.h"
////////////////////////////////////////////////////////////////////////////////
class nsFileIO : public nsIFileIO
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSISTREAMIO
NS_DECL_NSIFILEIO
nsFileIO();
virtual ~nsFileIO();
static NS_METHOD
Create(nsISupports *aOuter, REFNSIID aIID, void **aResult);
protected:
nsCOMPtr<nsIFile> mFile;
PRFileDesc* mFD;
PRInt32 mIOFlags;
PRInt32 mPerm;
nsresult mStatus;
nsCString mContentType;
#ifdef PR_LOGGING
nsCString mSpec;
#endif
};
////////////////////////////////////////////////////////////////////////////////
class nsFileStream : public nsISeekableStream
{
public:

205
netwerk/base/src/nsIOService.cpp
Просмотреть файл

@ -41,7 +41,6 @@
#include "nscore.h"
#include "nsIServiceManager.h"
#include "nsIEventQueueService.h"
#include "nsIFileTransportService.h"
#include "nsIURI.h"
#include "nsIStreamListener.h"
#include "prprf.h"
@ -53,7 +52,6 @@
#include "nsIErrorService.h"
#include "netCore.h"
#include "nsIObserverService.h"
#include "nsIHttpProtocolHandler.h"
#include "nsIPrefService.h"
#include "nsIPrefBranchInternal.h"
#include "nsIPrefLocalizedString.h"
@ -66,12 +64,14 @@
#include "nsEscape.h"
#include "nsNetCID.h"
#include "nsIRecyclingAllocator.h"
#include "nsISocketTransport.h"
#include "nsCRT.h"
#define PORT_PREF_PREFIX "network.security.ports."
#define PORT_PREF(x) PORT_PREF_PREFIX x
#define AUTODIAL_PREF "network.autodial-helper.enabled"
static NS_DEFINE_CID(kFileTransportService, NS_FILETRANSPORTSERVICE_CID);
static NS_DEFINE_CID(kStreamTransportServiceCID, NS_STREAMTRANSPORTSERVICE_CID);
static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID);
static NS_DEFINE_CID(kDNSServiceCID, NS_DNSSERVICE_CID);
static NS_DEFINE_CID(kErrorServiceCID, NS_ERRORSERVICE_CID);
@ -176,65 +176,52 @@ nsIOService::nsIOService()
nsresult
nsIOService::Init()
{
nsresult rv = NS_OK;
nsresult rv;
// Hold onto the eventQueue service. We do not want any eventqueues to go away
// when we shutdown until we process all remaining transports
if (NS_SUCCEEDED(rv))
mEventQueueService = do_GetService(NS_EVENTQUEUESERVICE_CONTRACTID, &rv);
mEventQueueService = do_GetService(NS_EVENTQUEUESERVICE_CONTRACTID);
if (NS_FAILED(rv))
NS_WARNING("failed to get event queue service");
// We need to get references to these services so that we can shut them
// down later. If we wait until the nsIOService is being shut down,
// GetService will fail at that point.
rv = nsServiceManager::GetService(kSocketTransportServiceCID,
NS_GET_IID(nsISocketTransportService),
getter_AddRefs(mSocketTransportService));
if (NS_FAILED(rv)) return rv;
mSocketTransportService = do_GetService(kSocketTransportServiceCID, &rv);
if (NS_FAILED(rv))
NS_WARNING("failed to get socket transport service");
rv = nsServiceManager::GetService(kFileTransportService,
NS_GET_IID(nsIFileTransportService),
getter_AddRefs(mFileTransportService));
if (NS_FAILED(rv)) return rv;
mStreamTransportService = do_GetService(kStreamTransportServiceCID, &rv);
if (NS_FAILED(rv))
NS_WARNING("failed to get stream transport service");
rv = nsServiceManager::GetService(kDNSServiceCID,
NS_GET_IID(nsIDNSService),
getter_AddRefs(mDNSService));
if (NS_FAILED(rv)) return rv;
mDNSService = do_GetService(kDNSServiceCID, &rv);
if (NS_FAILED(rv))
NS_WARNING("failed to get DNS service");
rv = nsServiceManager::GetService(kProtocolProxyServiceCID,
NS_GET_IID(nsIProtocolProxyService),
getter_AddRefs(mProxyService));
if (NS_FAILED(rv)) return rv;
mProxyService = do_GetService(kProtocolProxyServiceCID, &rv);
if (NS_FAILED(rv))
NS_WARNING("failed to get protocol proxy service");
// XXX hack until xpidl supports error info directly (http://bugzilla.mozilla.org/show_bug.cgi?id=13423)
nsCOMPtr<nsIErrorService> errorService = do_GetService(kErrorServiceCID, &rv);
if (NS_FAILED(rv))
return rv;
rv = errorService->RegisterErrorStringBundle(NS_ERROR_MODULE_NETWORK, NECKO_MSGS_URL);
if (NS_FAILED(rv)) return rv;
rv = errorService->RegisterErrorStringBundleKey(NS_NET_STATUS_READ_FROM, "ReadFrom");
if (NS_FAILED(rv)) return rv;
rv = errorService->RegisterErrorStringBundleKey(NS_NET_STATUS_WROTE_TO, "WroteTo");
if (NS_FAILED(rv)) return rv;
rv = errorService->RegisterErrorStringBundleKey(NS_NET_STATUS_RESOLVING_HOST, "ResolvingHost");
if (NS_FAILED(rv)) return rv;
rv = errorService->RegisterErrorStringBundleKey(NS_NET_STATUS_CONNECTED_TO, "ConnectedTo");
if (NS_FAILED(rv)) return rv;
rv = errorService->RegisterErrorStringBundleKey(NS_NET_STATUS_SENDING_TO, "SendingTo");
if (NS_FAILED(rv)) return rv;
rv = errorService->RegisterErrorStringBundleKey(NS_NET_STATUS_RECEIVING_FROM, "ReceivingFrom");
if (NS_FAILED(rv)) return rv;
rv = errorService->RegisterErrorStringBundleKey(NS_NET_STATUS_CONNECTING_TO, "ConnectingTo");
if (NS_FAILED(rv)) return rv;
// XXX hack until xpidl supports error info directly (bug 13423)
nsCOMPtr<nsIErrorService> errorService = do_GetService(kErrorServiceCID);
if (errorService) {
errorService->RegisterErrorStringBundle(NS_ERROR_MODULE_NETWORK, NECKO_MSGS_URL);
errorService->RegisterErrorStringBundleKey(nsISocketTransport::STATUS_RESOLVING, "ResolvingHost");
errorService->RegisterErrorStringBundleKey(nsISocketTransport::STATUS_CONNECTED_TO, "ConnectedTo");
errorService->RegisterErrorStringBundleKey(nsISocketTransport::STATUS_SENDING_TO, "SendingTo");
errorService->RegisterErrorStringBundleKey(nsISocketTransport::STATUS_RECEIVING_FROM, "ReceivingFrom");
errorService->RegisterErrorStringBundleKey(nsISocketTransport::STATUS_CONNECTING_TO, "ConnectingTo");
errorService->RegisterErrorStringBundleKey(nsISocketTransport::STATUS_WAITING_FOR, "WaitingFor");
}
else
NS_WARNING("failed to get error service");
// setup our bad port list stuff
for(int i=0; gBadPortList[i]; i++) {
for(int i=0; gBadPortList[i]; i++)
mRestrictedPortList.AppendElement(NS_REINTERPRET_CAST(void *, gBadPortList[i]));
}
// Further modifications to the port list come from prefs
nsCOMPtr<nsIPrefBranch> prefBranch;
@ -251,12 +238,13 @@ nsIOService::Init()
// Register for profile change notifications
nsCOMPtr<nsIObserverService> observerService =
do_GetService("@mozilla.org/observer-service;1");
NS_ASSERTION(observerService, "Failed to get observer service");
if (observerService) {
observerService->AddObserver(this, kProfileChangeNetTeardownTopic, PR_TRUE);
observerService->AddObserver(this, kProfileChangeNetRestoreTopic, PR_TRUE);
observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, PR_TRUE);
}
else
NS_WARNING("failed to get observer service");
return NS_OK;
}
@ -266,47 +254,6 @@ nsIOService::~nsIOService()
{
}
NS_METHOD
nsIOService::Create(nsISupports *aOuter, REFNSIID aIID, void **aResult)
{
static nsISupports *_rValue = nsnull;
nsresult rv;
NS_ENSURE_NO_AGGREGATION(aOuter);
if (_rValue)
{
NS_ADDREF (_rValue);
*aResult = _rValue;
return NS_OK;
}
nsIOService* _ios = new nsIOService();
if (_ios == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(_ios);
rv = _ios->Init();
if (NS_FAILED(rv))
{
delete _ios;
return rv;
}
rv = _ios->QueryInterface(aIID, aResult);
if (NS_FAILED(rv))
{
delete _ios;
return rv;
}
_rValue = NS_STATIC_CAST (nsISupports*, *aResult);
NS_RELEASE (_rValue);
_rValue = nsnull;
return rv;
}
NS_IMPL_THREADSAFE_ISUPPORTS3(nsIOService,
nsIIOService,
nsIObserver,
@ -481,8 +428,6 @@ nsIOService::NewChannelFromURI(nsIURI *aURI, nsIChannel **result)
{
nsresult rv;
NS_ENSURE_ARG_POINTER(aURI);
// If XPCOM shutdown has started, mProxyService could be null.
NS_ENSURE_TRUE(mProxyService, NS_ERROR_NOT_AVAILABLE);
NS_TIMELINE_MARK_URI("nsIOService::NewChannelFromURI(%s)", aURI);
nsCAutoString scheme;
@ -490,8 +435,11 @@ nsIOService::NewChannelFromURI(nsIURI *aURI, nsIChannel **result)
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIProxyInfo> pi;
rv = mProxyService->ExamineForProxy(aURI, getter_AddRefs(pi));
if (NS_FAILED(rv)) return rv;
if (mProxyService) {
rv = mProxyService->ExamineForProxy(aURI, getter_AddRefs(pi));
if (NS_FAILED(rv))
pi = 0;
}
nsCOMPtr<nsIProtocolHandler> handler;
@ -535,50 +483,56 @@ nsIOService::GetOffline(PRBool *offline)
NS_IMETHODIMP
nsIOService::SetOffline(PRBool offline)
{
nsCOMPtr<nsIObserverService>
observerService(do_GetService("@mozilla.org/observer-service;1"));
nsCOMPtr<nsIObserverService> observerService =
do_GetService("@mozilla.org/observer-service;1");
nsresult rv1 = NS_OK;
nsresult rv2 = NS_OK;
nsresult rv;
if (offline) {
NS_NAMED_LITERAL_STRING(offlineString, "offline");
mOffline = PR_TRUE; // indicate we're trying to shutdown
mOffline = PR_TRUE; // indicate we're trying to shutdown
// don't care if notification fails
if (observerService)
// this allows users to attempt a little cleanup before dns and socket transport are shut down.
(void)observerService->NotifyObservers(NS_STATIC_CAST(nsIIOService *, this),
"network:offline-about-to-go-offline",
offlineString.get());
// be sure to try and shutdown both (even if the first fails)
if (mDNSService)
rv1 = mDNSService->Shutdown(); // shutdown dns service first, because it has callbacks for socket transport
if (mSocketTransportService)
rv2 = mSocketTransportService->Shutdown();
if (NS_FAILED(rv1)) return rv1;
if (NS_FAILED(rv2)) return rv2;
if (observerService)
observerService->NotifyObservers(NS_STATIC_CAST(nsIIOService *, this),
"network:offline-about-to-go-offline",
offlineString.get());
// be sure to try and shutdown both (even if the first fails)...
// shutdown dns service first, because it has callbacks for socket transport
if (mDNSService) {
rv = mDNSService->Shutdown();
NS_ASSERTION(NS_SUCCEEDED(rv), "DNS service shutdown failed");
}
if (mSocketTransportService) {
rv = mSocketTransportService->Shutdown();
NS_ASSERTION(NS_SUCCEEDED(rv), "socket transport service shutdown failed");
}
// don't care if notification fails
if (observerService)
(void)observerService->NotifyObservers(NS_STATIC_CAST(nsIIOService *, this),
"network:offline-status-changed",
offlineString.get());
observerService->NotifyObservers(NS_STATIC_CAST(nsIIOService *, this),
"network:offline-status-changed",
offlineString.get());
}
else if (!offline && mOffline) {
// go online
if (mDNSService)
rv1 = mDNSService->Init();
if (NS_FAILED(rv2)) return rv1;
if (mSocketTransportService)
rv2 = mSocketTransportService->Init(); //XXX should we shutdown the dns service?
if (NS_FAILED(rv2)) return rv1;
if (mDNSService) {
rv = mDNSService->Init();
NS_ASSERTION(NS_SUCCEEDED(rv), "DNS service init failed");
}
if (mSocketTransportService) {
rv = mSocketTransportService->Init();
NS_ASSERTION(NS_SUCCEEDED(rv), "socket transport service init failed");
}
mOffline = PR_FALSE; // indicate success only AFTER we've
// brought up the services
// don't care if notification fails
if (observerService)
(void)observerService->NotifyObservers(NS_STATIC_CAST(nsIIOService *, this),
"network:offline-status-changed",
NS_LITERAL_STRING("online").get());
observerService->NotifyObservers(NS_STATIC_CAST(nsIIOService *, this),
"network:offline-status-changed",
NS_LITERAL_STRING("online").get());
}
return NS_OK;
}
@ -718,12 +672,13 @@ nsIOService::Observe(nsISupports *subject,
}
}
else if (!strcmp(topic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
(void)SetOffline(PR_TRUE);
if (mFileTransportService)
(void)mFileTransportService->Shutdown();
SetOffline(PR_TRUE);
if (mStreamTransportService)
mStreamTransportService->Shutdown();
// Break circular reference.
mProxyService = nsnull;
mProxyService = 0;
}
return NS_OK;
}

4
netwerk/base/src/nsIOService.h
Просмотреть файл

@ -42,7 +42,7 @@
#include "nsIIOService.h"
#include "nsVoidArray.h"
#include "nsISocketTransportService.h"
#include "nsIFileTransportService.h"
#include "nsIStreamTransportService.h"
#include "nsIDNSService.h"
#include "nsIProtocolProxyService.h"
#include "nsCOMPtr.h"
@ -103,7 +103,7 @@ protected:
PRPackedBool mOffline;
PRPackedBool mOfflineForProfileChange;
nsCOMPtr<nsISocketTransportService> mSocketTransportService;
nsCOMPtr<nsIFileTransportService> mFileTransportService;
nsCOMPtr<nsIStreamTransportService> mStreamTransportService;
nsCOMPtr<nsIDNSService> mDNSService;
nsCOMPtr<nsIProtocolProxyService> mProxyService;
nsCOMPtr<nsIEventQueueService> mEventQueueService;

557
netwerk/base/src/nsInputStreamChannel.cpp
Просмотреть файл

@ -36,233 +36,140 @@
* ***** END LICENSE BLOCK ***** */
#include "nsInputStreamChannel.h"
#include "nsCOMPtr.h"
#include "nsIIOService.h"
#include "nsIServiceManager.h"
#include "nsIFileTransportService.h"
#include "nsXPIDLString.h"
#include "nsIStreamTransportService.h"
#include "nsIEventQueueService.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsITransport.h"
#include "nsNetUtil.h"
#include "nsCOMPtr.h"
#include "prlog.h"
static NS_DEFINE_CID(kFileTransportServiceCID, NS_FILETRANSPORTSERVICE_CID);
static NS_DEFINE_CID(kStreamTransportServiceCID, NS_STREAMTRANSPORTSERVICE_CID);
static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
////////////////////////////////////////////////////////////////////////////////
// nsInputStreamIO methods:
#if defined(PR_LOGGING)
//
// NSPR_LOG_MODULES=nsStreamChannel:5
//
static PRLogModuleInfo *gStreamChannelLog = nsnull;
#endif
NS_IMPL_THREADSAFE_ISUPPORTS2(nsInputStreamIO,
nsIInputStreamIO,
nsIStreamIO)
#define LOG(args) PR_LOG(gStreamChannelLog, PR_LOG_DEBUG, args)
#define LOG_ENABLED() PR_LOG_TEST(gStreamChannelLog, 4)
nsInputStreamIO::nsInputStreamIO()
: mContentLength(-1), mStatus(NS_OK)
//-----------------------------------------------------------------------------
// nsInputStreamChannel methods
//-----------------------------------------------------------------------------
nsInputStreamChannel::nsInputStreamChannel()
: mContentLength(-1)
, mLoadFlags(LOAD_NORMAL)
, mStatus(NS_OK)
{
#if defined(PR_LOGGING)
if (!gStreamChannelLog)
gStreamChannelLog = PR_NewLogModule("nsStreamChannel");
#endif
}
nsInputStreamChannel::~nsInputStreamChannel()
{
}
nsInputStreamIO::~nsInputStreamIO()
{
Close(NS_OK);
}
//-----------------------------------------------------------------------------
// nsInputStreamChannel::nsISupports
//-----------------------------------------------------------------------------
NS_METHOD
nsInputStreamIO::Create(nsISupports *aOuter, REFNSIID aIID, void **aResult)
{
if (aOuter)
return NS_ERROR_NO_AGGREGATION;
nsInputStreamIO* io = new nsInputStreamIO();
if (io == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(io);
nsresult rv = io->QueryInterface(aIID, aResult);
NS_RELEASE(io);
return rv;
}
NS_IMPL_ISUPPORTS5(nsInputStreamChannel,
nsIChannel,
nsIRequest,
nsIStreamListener,
nsIRequestObserver,
nsIInputStreamChannel)
//-----------------------------------------------------------------------------
// nsInputStreamChannel::nsIRequest
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsInputStreamIO::Init(const nsACString &name,
nsIInputStream* input,
const nsACString &contentType,
const nsACString &contentCharset,
PRInt32 contentLength)
{
mName = name;
mInputStream = input;
mContentLength = contentLength;
mContentCharset = contentCharset;
// mContentCharset is unchanged if not parsed
NS_ParseContentType(contentType, mContentType, mContentCharset);
return NS_OK;
}
NS_IMETHODIMP
nsInputStreamIO::Open()
{
return NS_OK;
}
NS_IMETHODIMP
nsInputStreamIO::GetContentType(nsACString &aContentType)
{
aContentType = mContentType;
return NS_OK;
}
NS_IMETHODIMP
nsInputStreamIO::GetContentCharset(nsACString &aContentCharset)
{
aContentCharset = mContentCharset;
return NS_OK;
}
NS_IMETHODIMP
nsInputStreamIO::GetContentLength(PRInt32 *aContentLength)
{
*aContentLength = mContentLength;
return NS_OK;
}
NS_IMETHODIMP
nsInputStreamIO::Close(nsresult status)
{
mStatus = status;
if (mInputStream)
return mInputStream->Close();
return NS_OK;
}
NS_IMETHODIMP
nsInputStreamIO::GetInputStream(nsIInputStream * *aInputStream)
{
*aInputStream = mInputStream;
NS_IF_ADDREF(*aInputStream);
return NS_OK;
}
NS_IMETHODIMP
nsInputStreamIO::GetOutputStream(nsIOutputStream * *aOutputStream)
{
// this method should never be called
NS_NOTREACHED("nsInputStreamIO::GetOutputStream");
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsInputStreamIO::GetName(nsACString &aName)
{
aName = mName;
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsStreamIOChannel methods:
nsStreamIOChannel::nsStreamIOChannel()
: mContentLength(-1),
mBufferSegmentSize(0), mBufferMaxSize(0),
mLoadFlags(LOAD_NORMAL), mStatus(NS_OK)
{
}
nsStreamIOChannel::~nsStreamIOChannel()
{
}
NS_METHOD
nsStreamIOChannel::Create(nsISupports *aOuter, REFNSIID aIID,
void **aResult)
{
if (aOuter)
return NS_ERROR_NO_AGGREGATION;
nsStreamIOChannel* channel = new nsStreamIOChannel();
if (channel == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(channel);
nsresult rv = channel->QueryInterface(aIID, aResult);
NS_RELEASE(channel);
return rv;
}
NS_IMETHODIMP
nsStreamIOChannel::Init(nsIURI* uri, nsIStreamIO* io)
{
mURI = uri;
mStreamIO = io;
return NS_OK;
}
NS_INTERFACE_MAP_BEGIN(nsStreamIOChannel)
NS_INTERFACE_MAP_ENTRY(nsIStreamIOChannel)
NS_INTERFACE_MAP_ENTRY(nsIChannel)
NS_INTERFACE_MAP_ENTRY(nsIRequest)
NS_INTERFACE_MAP_ENTRY(nsIStreamListener)
NS_INTERFACE_MAP_ENTRY(nsIStreamProvider)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIRequestObserver, nsIStreamListener)
NS_INTERFACE_MAP_ENTRY(nsIProgressEventSink)
NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIStreamListener)
NS_INTERFACE_MAP_END_THREADSAFE
NS_IMPL_THREADSAFE_ADDREF(nsStreamIOChannel)
NS_IMPL_THREADSAFE_RELEASE(nsStreamIOChannel)
NS_IMETHODIMP
nsStreamIOChannel::GetName(nsACString &result)
nsInputStreamChannel::GetName(nsACString &result)
{
return mURI->GetSpec(result);
}
NS_IMETHODIMP
nsStreamIOChannel::IsPending(PRBool *result)
nsInputStreamChannel::IsPending(PRBool *result)
{
if (mRequest)
return mRequest->IsPending(result);
*result = PR_FALSE;
NS_ENSURE_TRUE(mPump, NS_ERROR_NOT_INITIALIZED);
return mPump->IsPending(result);
}
NS_IMETHODIMP
nsInputStreamChannel::GetStatus(nsresult *status)
{
if (mPump && NS_SUCCEEDED(mStatus))
mPump->GetStatus(status);
else
*status = mStatus;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetStatus(nsresult *status)
nsInputStreamChannel::Cancel(nsresult status)
{
*status = mStatus;
// if we don't have a status error of our own to report
// then we should propagate the status error of the underlying
// file transport (if we have one)
if (NS_SUCCEEDED(mStatus) && mRequest)
mRequest->GetStatus(status);
NS_ENSURE_TRUE(mPump, NS_ERROR_NOT_INITIALIZED);
return mPump->Cancel(status);
}
NS_IMETHODIMP
nsInputStreamChannel::Suspend()
{
NS_ENSURE_TRUE(mPump, NS_ERROR_NOT_INITIALIZED);
return mPump->Suspend();
}
NS_IMETHODIMP
nsInputStreamChannel::Resume()
{
NS_ENSURE_TRUE(mPump, NS_ERROR_NOT_INITIALIZED);
return mPump->Resume();
}
NS_IMETHODIMP
nsInputStreamChannel::GetLoadFlags(nsLoadFlags *aLoadFlags)
{
*aLoadFlags = mLoadFlags;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::Cancel(nsresult status)
nsInputStreamChannel::SetLoadFlags(nsLoadFlags aLoadFlags)
{
NS_ASSERTION(NS_FAILED(status), "shouldn't cancel with a success code");
mStatus = status;
if (mRequest)
return mRequest->Cancel(status);
mLoadFlags = aLoadFlags;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::Suspend(void)
nsInputStreamChannel::GetLoadGroup(nsILoadGroup **aLoadGroup)
{
if (mRequest)
return mRequest->Suspend();
NS_IF_ADDREF(*aLoadGroup = mLoadGroup);
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::Resume(void)
nsInputStreamChannel::SetLoadGroup(nsILoadGroup *aLoadGroup)
{
if (mRequest)
return mRequest->Resume();
mLoadGroup = aLoadGroup;
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsIChannel implementation:
////////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// nsInputStreamChannel::nsIChannel implementation
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsStreamIOChannel::GetOriginalURI(nsIURI* *aURI)
nsInputStreamChannel::GetOriginalURI(nsIURI **aURI)
{
*aURI = mOriginalURI ? mOriginalURI : mURI;
NS_IF_ADDREF(*aURI);
@ -270,153 +177,64 @@ nsStreamIOChannel::GetOriginalURI(nsIURI* *aURI)
}
NS_IMETHODIMP
nsStreamIOChannel::SetOriginalURI(nsIURI* aURI)
nsInputStreamChannel::SetOriginalURI(nsIURI *aURI)
{
mOriginalURI = aURI;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetURI(nsIURI* *aURI)
nsInputStreamChannel::GetURI(nsIURI **aURI)
{
*aURI = mURI;
NS_IF_ADDREF(*aURI);
NS_IF_ADDREF(*aURI = mURI);
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::Open(nsIInputStream **result)
nsInputStreamChannel::GetOwner(nsISupports **aOwner)
{
// XXX not calling mStreamIO->Open(), does that matter?
return mStreamIO->GetInputStream(result);
}
NS_IMETHODIMP
nsStreamIOChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt)
{
nsresult rv;
NS_ASSERTION(listener, "no listener");
SetListener(listener);
if (mLoadGroup) {
rv = mLoadGroup->AddRequest(this, nsnull);
if (NS_FAILED(rv)) return rv;
}
if (mFileTransport == nsnull) {
nsCOMPtr<nsIFileTransportService> fts =
do_GetService(kFileTransportServiceCID, &rv);
if (NS_FAILED(rv)) goto done;
rv = fts->CreateTransportFromStreamIO(mStreamIO, PR_TRUE,
getter_AddRefs(mFileTransport));
if (NS_FAILED(rv)) goto done;
}
// Hook up the notification callbacks InterfaceRequestor...
{
nsCOMPtr<nsIInterfaceRequestor> requestor =
do_QueryInterface(NS_STATIC_CAST(nsIRequest*, this));
rv = mFileTransport->SetNotificationCallbacks
(requestor, (mLoadFlags & nsIRequest::LOAD_BACKGROUND));
if (NS_FAILED(rv)) goto done;
}
rv = mFileTransport->AsyncRead(this, ctxt, 0, PRUint32(-1), 0, getter_AddRefs(mRequest));
done:
if (NS_FAILED(rv)) {
nsresult rv2;
rv2 = mLoadGroup->RemoveRequest(this, ctxt, rv);
NS_ASSERTION(NS_SUCCEEDED(rv2), "RemoveRequest failed");
// release the transport so that we don't think we're in progress
mFileTransport = nsnull;
}
return rv;
}
NS_IMETHODIMP
nsStreamIOChannel::GetLoadFlags(nsLoadFlags *aLoadFlags)
{
*aLoadFlags = mLoadFlags;
NS_IF_ADDREF(*aOwner = mOwner);
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetLoadFlags(nsLoadFlags aLoadFlags)
{
mLoadFlags = aLoadFlags;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
{
*aLoadGroup = mLoadGroup.get();
NS_IF_ADDREF(*aLoadGroup);
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetLoadGroup(nsILoadGroup* aLoadGroup)
{
mLoadGroup = aLoadGroup;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetOwner(nsISupports* *aOwner)
{
*aOwner = mOwner.get();
NS_IF_ADDREF(*aOwner);
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetOwner(nsISupports* aOwner)
nsInputStreamChannel::SetOwner(nsISupports *aOwner)
{
mOwner = aOwner;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetNotificationCallbacks(nsIInterfaceRequestor* *aNotificationCallbacks)
nsInputStreamChannel::GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks)
{
*aNotificationCallbacks = mCallbacks.get();
NS_IF_ADDREF(*aNotificationCallbacks);
return NS_OK;
NS_IF_ADDREF(*aCallbacks = mCallbacks);
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aNotificationCallbacks)
nsInputStreamChannel::SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks)
{
nsresult rv = NS_OK;
mCallbacks = aNotificationCallbacks;
mProgressSink = do_GetInterface(mCallbacks);
return rv;
mCallbacks = aCallbacks;
mProgressSink = do_GetInterface(mCallbacks);
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetSecurityInfo(nsISupports * *aSecurityInfo)
nsInputStreamChannel::GetSecurityInfo(nsISupports **aSecurityInfo)
{
*aSecurityInfo = nsnull;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetContentType(nsACString &aContentType)
nsInputStreamChannel::GetContentType(nsACString &aContentType)
{
if (mContentType.IsEmpty()) {
nsresult rv = mStreamIO->GetContentType(mContentType);
if (NS_FAILED(rv)) return rv;
}
aContentType = mContentType;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetContentType(const nsACString &aContentType)
nsInputStreamChannel::SetContentType(const nsACString &aContentType)
{
// mContentCharset is unchanged if not parsed
NS_ParseContentType(aContentType, mContentType, mContentCharset);
@ -424,133 +242,134 @@ nsStreamIOChannel::SetContentType(const nsACString &aContentType)
}
NS_IMETHODIMP
nsStreamIOChannel::GetContentCharset(nsACString &aContentCharset)
nsInputStreamChannel::GetContentCharset(nsACString &aContentCharset)
{
if (mContentCharset.IsEmpty()) {
nsresult rv = mStreamIO->GetContentCharset(mContentCharset);
if (NS_FAILED(rv)) return rv;
}
aContentCharset = mContentCharset;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetContentCharset(const nsACString &aContentCharset)
nsInputStreamChannel::SetContentCharset(const nsACString &aContentCharset)
{
mContentCharset = aContentCharset;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::GetContentLength(PRInt32 *aContentLength)
nsInputStreamChannel::GetContentLength(PRInt32 *aContentLength)
{
nsresult rv;
if (mContentLength == -1) {
rv = mStreamIO->GetContentLength(&mContentLength);
if (NS_FAILED(rv)) return rv;
}
*aContentLength = mContentLength;
return NS_OK;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::SetContentLength(PRInt32 aContentLength)
nsInputStreamChannel::SetContentLength(PRInt32 aContentLength)
{
// XXX does this really make any sense at all?
mContentLength = aContentLength;
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsIRequestObserver implementation:
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsStreamIOChannel::OnStartRequest(nsIRequest *request, nsISupports* context)
nsInputStreamChannel::Open(nsIInputStream **result)
{
NS_ASSERTION(mUserObserver, "No listener...");
return mUserObserver->OnStartRequest(this, context);
NS_ENSURE_TRUE(mContentStream, NS_ERROR_NOT_INITIALIZED);
NS_ENSURE_TRUE(!mPump, NS_ERROR_IN_PROGRESS);
NS_ADDREF(*result = mContentStream);
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::OnStopRequest(nsIRequest *request, nsISupports* context, nsresult aStatus)
nsInputStreamChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt)
{
if (mUserObserver)
mUserObserver->OnStopRequest(this, context, aStatus);
NS_ENSURE_TRUE(mContentStream, NS_ERROR_NOT_INITIALIZED);
NS_ENSURE_TRUE(!mPump, NS_ERROR_IN_PROGRESS);
if (mContentLength == -1)
mContentStream->Available((PRUint32 *) &mContentLength);
nsresult rv = NS_NewInputStreamPump(getter_AddRefs(mPump), mContentStream,
-1, mContentLength, 0, 0, PR_TRUE);
if (NS_FAILED(rv)) return rv;
rv = mPump->AsyncRead(this, nsnull);
if (NS_FAILED(rv)) return rv;
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, context, aStatus);
mLoadGroup->AddRequest(this, nsnull);
// Release the reference to the consumer stream listener...
mRequest = 0;
mFileTransport = 0;
mUserObserver = 0;
// Make sure the stream io is closed
mStreamIO->Close(aStatus);
// There is no point in returning anything other than NS_OK
mListener = listener;
mListenerContext = ctxt;
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsIStreamListener implementation:
////////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// nsInputStreamChannel::nsIInputStreamChannel implementation
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsStreamIOChannel::OnDataAvailable(nsIRequest *request, nsISupports* context,
nsIInputStream *aIStream, PRUint32 aSourceOffset,
PRUint32 aLength)
nsInputStreamChannel::SetURI(nsIURI *uri)
{
return GetListener()->OnDataAvailable(this, context, aIStream,
aSourceOffset, aLength);
}
////////////////////////////////////////////////////////////////////////////////
// nsIStreamProvider implementation:
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsStreamIOChannel::OnDataWritable(nsIRequest *request, nsISupports *context,
nsIOutputStream *aOStream,
PRUint32 aOffset, PRUint32 aLength)
{
return GetProvider()->OnDataWritable(this, context, aOStream,
aOffset, aLength);
}
////////////////////////////////////////////////////////////////////////////////
// nsIProgressEventSink implementation:
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsStreamIOChannel::OnProgress(nsIRequest *request, nsISupports *context,
PRUint32 progress, PRUint32 progressMax)
{
if (mProgressSink)
mProgressSink->OnProgress(this, context, progress, progressMax);
NS_ENSURE_TRUE(!mPump, NS_ERROR_IN_PROGRESS);
mURI = uri;
return NS_OK;
}
NS_IMETHODIMP
nsStreamIOChannel::OnStatus(nsIRequest *request, nsISupports *context,
nsresult status, const PRUnichar *statusText)
nsInputStreamChannel::GetContentStream(nsIInputStream **stream)
{
if (mProgressSink)
mProgressSink->OnStatus(this, context, status, statusText);
NS_IF_ADDREF(*stream = mContentStream);
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsIInterfaceRequestor implementation:
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsStreamIOChannel::GetInterface(const nsIID &iid, void **result)
nsInputStreamChannel::SetContentStream(nsIInputStream *stream)
{
if (iid.Equals(NS_GET_IID(nsIProgressEventSink)))
return QueryInterface(iid, result);
return NS_ERROR_NO_INTERFACE;
NS_ENSURE_TRUE(!mPump, NS_ERROR_IN_PROGRESS);
mContentStream = stream;
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// nsInputStreamChannel::nsIStreamListener implementation
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsInputStreamChannel::OnStartRequest(nsIRequest *req, nsISupports *ctx)
{
return mListener->OnStartRequest(this, mListenerContext);
}
NS_IMETHODIMP
nsInputStreamChannel::OnStopRequest(nsIRequest *req, nsISupports *ctx, nsresult status)
{
if (NS_SUCCEEDED(mStatus))
mStatus = status;
mListener->OnStopRequest(this, mListenerContext, mStatus);
mListener = 0;
mListenerContext = 0;
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nsnull, mStatus);
mPump = 0;
mContentStream = 0;
return NS_OK;
}
NS_IMETHODIMP
nsInputStreamChannel::OnDataAvailable(nsIRequest *req, nsISupports *ctx,
nsIInputStream *stream,
PRUint32 offset, PRUint32 count)
{
nsresult rv;
rv = mListener->OnDataAvailable(this, mListenerContext, stream, offset, count);
if (mProgressSink && NS_SUCCEEDED(rv) && !(mLoadFlags & LOAD_BACKGROUND))
mProgressSink->OnProgress(this, nsnull, offset + count, mContentLength);
return rv; // let the pump cancel on failure
}

76
netwerk/base/src/nsInputStreamChannel.h
Просмотреть файл

@ -38,91 +38,51 @@
#ifndef nsInputStreamChannel_h__
#define nsInputStreamChannel_h__
#include "nsIStreamIOChannel.h"
#include "nsString.h"
#include "nsCOMPtr.h"
#include "nsIInputStreamChannel.h"
#include "nsIInputStreamPump.h"
#include "nsIInputStream.h"
#include "nsIURI.h"
#include "nsCRT.h"
#include "nsILoadGroup.h"
#include "nsIStreamListener.h"
#include "nsIStreamProvider.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsIProgressEventSink.h"
#include "nsIStreamIO.h"
#include "nsITransport.h"
#include "nsString.h"
class nsInputStreamIO : public nsIInputStreamIO
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSISTREAMIO
NS_DECL_NSIINPUTSTREAMIO
//-----------------------------------------------------------------------------
nsInputStreamIO();
virtual ~nsInputStreamIO();
static NS_METHOD
Create(nsISupports *aOuter, REFNSIID aIID, void **aResult);
protected:
nsCString mName;
nsCOMPtr<nsIInputStream> mInputStream;
nsCString mContentType;
nsCString mContentCharset;
PRInt32 mContentLength;
nsresult mStatus;
};
////////////////////////////////////////////////////////////////////////////////
class nsStreamIOChannel : public nsIStreamIOChannel,
public nsIStreamListener,
public nsIStreamProvider,
public nsIProgressEventSink,
public nsIInterfaceRequestor
class nsInputStreamChannel : public nsIInputStreamChannel
, public nsIStreamListener
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIREQUEST
NS_DECL_NSICHANNEL
NS_DECL_NSISTREAMIOCHANNEL
NS_DECL_NSIINPUTSTREAMCHANNEL
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSISTREAMLISTENER
NS_DECL_NSISTREAMPROVIDER
NS_DECL_NSIPROGRESSEVENTSINK
NS_DECL_NSIINTERFACEREQUESTOR
nsStreamIOChannel();
virtual ~nsStreamIOChannel();
static NS_METHOD
Create(nsISupports *aOuter, REFNSIID aIID, void **aResult);
nsInputStreamChannel();
virtual ~nsInputStreamChannel();
protected:
nsIStreamListener* GetListener() { return (nsIStreamListener*)mUserObserver.get(); }
void SetListener(nsIStreamListener* listener) { mUserObserver = listener; }
nsIStreamProvider* GetProvider() { return (nsIStreamProvider*)mUserObserver.get(); }
void SetProvider(nsIStreamProvider* provider) { mUserObserver = provider; }
protected:
nsCOMPtr<nsIInputStreamPump> mPump;
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsIProgressEventSink> mProgressSink;
nsCOMPtr<nsIURI> mOriginalURI;
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsISupports> mOwner;
nsCOMPtr<nsIStreamListener> mListener;
nsCOMPtr<nsISupports> mListenerContext;
nsCOMPtr<nsIInputStream> mContentStream;
nsCString mContentType;
nsCString mContentCharset;
PRInt32 mContentLength;
nsCOMPtr<nsIStreamIO> mStreamIO;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsISupports> mOwner;
nsCOMPtr<nsITransport> mFileTransport;
nsCOMPtr<nsIRequest> mRequest;
nsCOMPtr<nsIRequestObserver> mUserObserver;
PRUint32 mBufferSegmentSize;
PRUint32 mBufferMaxSize;
PRUint32 mLoadFlags;
nsresult mStatus;
};
#endif // nsInputStreamChannel_h__
#endif // !nsInputStreamChannel_h__

6
netwerk/base/src/nsProtocolProxyService.cpp
Просмотреть файл

@ -441,11 +441,11 @@ nsProtocolProxyService::NewProxyInfo(const char *aType,
const char *type = nsnull;
// canonicalize type
if (PL_strcasecmp(aType, "http"))
if (PL_strcasecmp(aType, "http") == 0)
type = "http";
else if (PL_strcasecmp(aType, "socks"))
else if (PL_strcasecmp(aType, "socks") == 0)
type = "socks";
else if (PL_strcasecmp(aType, "socks4"))
else if (PL_strcasecmp(aType, "socks4") == 0)
type = "socks4";
else
return NS_ERROR_INVALID_ARG;

2
netwerk/base/src/nsStreamLoader.cpp
Просмотреть файл

@ -40,7 +40,7 @@
#include "nsIURL.h"
#include "nsNetUtil.h"
#include "nsIChannel.h"
#include "nsIHttpChannel.h"
//#include "nsIHttpChannel.h"
#include "nsProxiedService.h"
static NS_DEFINE_CID(kProxyObjectManagerCID, NS_PROXYEVENT_MANAGER_CID);

220
netwerk/build/nsNetCID.h
Просмотреть файл

@ -152,32 +152,6 @@
{0x9c, 0x46, 0xd0, 0x3f, 0xaa, 0x7b, 0x69, 0x6b} \
}
// component implementing nsIStreamListenerProxy.
#define NS_STREAMLISTENERPROXY_CLASSNAME \
"nsStreamListenerProxy"
#define NS_STREAMLISTENERPROXY_CONTRACTID \
"@mozilla.org/network/stream-listener-proxy;1"
#define NS_STREAMLISTENERPROXY_CID \
{ /* 96c48f15-aa8a-4da7-a9d5-e842bd76f015 */ \
0x96c48f15, \
0xaa8a, \
0x4da7, \
{0xa9, 0xd5, 0xe8, 0x42, 0xbd, 0x76, 0xf0, 0x15} \
}
// component implementing nsIStreamProviderProxy.
#define NS_STREAMPROVIDERPROXY_CLASSNAME \
"nsStreamProviderProxy"
#define NS_STREAMPROVIDERPROXY_CONTRACTID \
"@mozilla.org/network/stream-provider-proxy;1"
#define NS_STREAMPROVIDERPROXY_CID \
{ /* ae964fcf-9c27-40f7-9bbd-78894bfc1f31 */ \
0xae964fcf, \
0x9c27, \
0x40f7, \
{0x9b, 0xbd, 0x78, 0x89, 0x4b, 0xfc, 0x1f, 0x31} \
}
// component implementing nsISimpleStreamListener.
#define NS_SIMPLESTREAMLISTENER_CLASSNAME \
"nsSimpleStreamListener"
@ -191,19 +165,6 @@
{0xb1, 0xd6, 0x53, 0x88, 0xe0, 0x41, 0xfb, 0x67} \
}
// component implementing nsISimpleStreamProvider.
#define NS_SIMPLESTREAMPROVIDER_CLASSNAME \
"nsSimpleStreamProvider"
#define NS_SIMPLESTREAMPROVIDER_CONTRACTID \
"@mozilla.org/network/simple-stream-provider;1"
#define NS_SIMPLESTREAMPROVIDER_CID \
{ /* f9f6a519-4efb-4f36-af40-2a5ec3992710 */ \
0xf9f6a519, \
0x4efb, \
0x4f36, \
{0xaf, 0x40, 0x2a, 0x5e, 0xc3, 0x99, 0x27, 0x10} \
}
// DEPRECATED component implementing nsIAsyncStreamListener.
#define NS_ASYNCSTREAMLISTENER_CLASSNAME \
"nsAsyncStreamListener"
@ -230,31 +191,38 @@
{0xb0, 0x2e, 0x77, 0xc8, 0x81, 0xcc, 0x57, 0x73} \
}
// A simple implementation of nsITransport that stores a segmented memory
// buffer (4k chunks). As long as the nsITransport is referenced, the data
// remains in memory. It can be read multiple times (only AsyncRead is
// implemented). There can be only one writer at a time (only OpenOutputStream
// is implemented). AsyncRead can be called while an output stream is still
// being written to. The readers will get notified automatically as more
// data is written via the output stream.
#define NS_STORAGETRANSPORT_CLASSNAME \
"nsStorageTransport"
#define NS_STORAGETRANSPORT_CONTRACTID \
"@mozilla.org/network/storage-transport;1"
#define NS_STORAGETRANSPORT_CID \
{ /* 5e955cdb-1334-4b8f-86b5-3b0f4d54b9d2 */ \
0x5e955cdb, \
0x1334, \
0x4b8f, \
{0x86, 0xb5, 0x3b, 0x0f, 0x4d, 0x54, 0xb9, 0xd2} \
// component implementing nsIAsyncStreamCopier.
#define NS_ASYNCSTREAMCOPIER_CLASSNAME \
"nsAsyncStreamCopier"
#define NS_ASYNCSTREAMCOPIER_CONTRACTID \
"@mozilla.org/network/async-stream-copier;1"
#define NS_ASYNCSTREAMCOPIER_CID \
{ /* e746a8b1-c97a-4fc5-baa4-66607521bd08 */ \
0xe746a8b1, \
0xc97a, \
0x4fc5, \
{0xba, 0xa4, 0x66, 0x60, 0x75, 0x21, 0xbd, 0x08} \
}
// component implementing nsIStreamIOChannel.
#define NS_STREAMIOCHANNEL_CLASSNAME \
// component implementing nsIInputStreamPump.
#define NS_INPUTSTREAMPUMP_CLASSNAME \
"nsInputStreamPump"
#define NS_INPUTSTREAMPUMP_CONTRACTID \
"@mozilla.org/network/input-stream-pump;1"
#define NS_INPUTSTREAMPUMP_CID \
{ /* ccd0e960-7947-4635-b70e-4c661b63d675 */ \
0xccd0e960, \
0x7947, \
0x4635, \
{0xb7, 0x0e, 0x4c, 0x66, 0x1b, 0x63, 0xd6, 0x75} \
}
// component implementing nsIInputStreamChannel.
#define NS_INPUTSTREAMCHANNEL_CLASSNAME \
"nsInputStreamChannel"
#define NS_STREAMIOCHANNEL_CONTRACTID \
"@mozilla.org/network/stream-io-channel;1"
#define NS_STREAMIOCHANNEL_CID \
#define NS_INPUTSTREAMCHANNEL_CONTRACTID \
"@mozilla.org/network/input-stream-channel;1"
#define NS_INPUTSTREAMCHANNEL_CID \
{ /* 6ddb050c-0d04-11d4-986e-00c04fa0cf4a */ \
0x6ddb050c, \
0x0d04, \
@ -327,6 +295,92 @@
{0xb9, 0x5c, 0xe5, 0xd6, 0x7a, 0x34, 0xe6, 0xb3} \
}
// service implementing nsIStreamTransportService
#define NS_STREAMTRANSPORTSERVICE_CLASSNAME \
"nsStreamTransportService"
#define NS_STREAMTRANSPORTSERVICE_CONTRACTID \
"@mozilla.org/network/stream-transport-service;1"
#define NS_STREAMTRANSPORTSERVICE_CID \
{ /* 0885d4f8-f7b8-4cda-902e-94ba38bc256e */ \
0x0885d4f8, \
0xf7b8, \
0x4cda, \
{0x90, 0x2e, 0x94, 0xba, 0x38, 0xbc, 0x25, 0x6e} \
}
// service implementing nsISocketTransportService
#define NS_SOCKETTRANSPORTSERVICE_CLASSNAME \
"nsSocketTransportService"
#define NS_SOCKETTRANSPORTSERVICE_CONTRACTID \
"@mozilla.org/network/socket-transport-service;1"
#define NS_SOCKETTRANSPORTSERVICE_CID \
{ /* c07e81e0-ef12-11d2-92b6-00105a1b0d64 */ \
0xc07e81e0, \
0xef12, \
0x11d2, \
{0x92, 0xb6, 0x00, 0x10, 0x5a, 0x1b, 0x0d, 0x64} \
}
#define NS_FILETRANSPORTSERVICE_CLASSNAME \
"nsFileTransportService"
#define NS_FILETRANSPORTSERVICE_CONTRACTID \
"@mozilla.org/network/file-transport-service;1"
#define NS_FILETRANSPORTSERVICE_CID \
{ /* 2bb2b250-ea35-11d2-931b-00104ba0fd40 */ \
0x2bb2b250, \
0xea35, \
0x11d2, \
{0x93, 0x1b, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40} \
}
#define NS_LOCALFILEINPUTSTREAM_CLASSNAME \
"nsFileInputStream"
#define NS_LOCALFILEINPUTSTREAM_CONTRACTID \
"@mozilla.org/network/file-input-stream;1"
#define NS_LOCALFILEINPUTSTREAM_CID \
{ /* be9a53ae-c7e9-11d3-8cda-0060b0fc14a3 */ \
0xbe9a53ae, \
0xc7e9, \
0x11d3, \
{0x8c, 0xda, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3} \
}
#define NS_LOCALFILEOUTPUTSTREAM_CLASSNAME \
"nsFileOutputStream"
#define NS_LOCALFILEOUTPUTSTREAM_CONTRACTID \
"@mozilla.org/network/file-output-stream;1"
#define NS_LOCALFILEOUTPUTSTREAM_CID \
{ /* c272fee0-c7e9-11d3-8cda-0060b0fc14a3 */ \
0xc272fee0, \
0xc7e9, \
0x11d3, \
{0x8c, 0xda, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3} \
}
#define NS_BUFFEREDINPUTSTREAM_CLASSNAME \
"nsBufferedInputStream"
#define NS_BUFFEREDINPUTSTREAM_CONTRACTID \
"@mozilla.org/network/buffered-input-stream;1"
#define NS_BUFFEREDINPUTSTREAM_CID \
{ /* 9226888e-da08-11d3-8cda-0060b0fc14a3 */ \
0x9226888e, \
0xda08, \
0x11d3, \
{0x8c, 0xda, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3} \
}
#define NS_BUFFEREDOUTPUTSTREAM_CLASSNAME \
"nsBufferedOutputStream"
#define NS_BUFFEREDOUTPUTSTREAM_CONTRACTID \
"@mozilla.org/network/buffered-output-stream;1"
#define NS_BUFFEREDOUTPUTSTREAM_CID \
{ /* 9868b4ce-da08-11d3-8cda-0060b0fc14a3 */ \
0x9868b4ce, \
0xda08, \
0x11d3, \
{0x8c, 0xda, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3} \
}
/******************************************************************************
* netwerk/cache/ classes
@ -386,6 +440,8 @@
* netwerk/protocol/res/ classes
*/
#define NS_RESPROTOCOLHANDLER_CLASSNAME \
"nsResProtocolHandler"
#define NS_RESPROTOCOLHANDLER_CID \
{ /* e64f152a-9f07-11d3-8cda-0060b0fc14a3 */ \
0xe64f152a, \
@ -394,6 +450,48 @@
{0x8c, 0xda, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3} \
}
/******************************************************************************
* netwerk/protocol/file/ classes
*/
#define NS_FILEPROTOCOLHANDLER_CLASSNAME \
"nsFileProtocolHandler"
#define NS_FILEPROTOCOLHANDLER_CID \
{ /* fbc81170-1f69-11d3-9344-00104ba0fd40 */ \
0xfbc81170, \
0x1f69, \
0x11d3, \
{0x93, 0x44, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40} \
}
/******************************************************************************
* netwerk/protocol/data/ classes
*/
#define NS_DATAPROTOCOLHANDLER_CLASSNAME \
"nsDataProtocolHandler"
#define NS_DATAPROTOCOLHANDLER_CID \
{ /* {B6ED3030-6183-11d3-A178-0050041CAF44} */ \
0xb6ed3030, \
0x6183, \
0x11d3, \
{0xa1, 0x78, 0x00, 0x50, 0x04, 0x1c, 0xaf, 0x44} \
}
/******************************************************************************
* netwerk/protocol/data/ classes
*/
#define NS_JARPROTOCOLHANDLER_CLASSNAME \
"nsJarProtocolHandler"
#define NS_JARPROTOCOLHANDLER_CID \
{ /* 0xc7e410d4-0x85f2-11d3-9f63-006008a6efe9 */ \
0xc7e410d4, \
0x85f2, \
0x11d3, \
{0x9f, 0x63, 0x00, 0x60, 0x08, 0xa6, 0xef, 0xe9} \
}
/******************************************************************************
* netwerk/dns/ classes

132
netwerk/build/nsNetModule.cpp
Просмотреть файл

@ -41,16 +41,12 @@
#include "nsIComponentManager.h"
#include "nsIServiceManager.h"
#include "nsICategoryManager.h"
#include "nsIOService.h"
#include "nsNetModuleMgr.h"
#include "nsFileTransportService.h"
#include "nsSocketTransportService.h"
#include "nsSocketProviderService.h"
#include "nscore.h"
#include "nsSimpleURI.h"
#include "nsDnsService.h"
#include "nsLoadGroup.h"
#include "nsInputStreamChannel.h"
#include "nsStreamLoader.h"
#include "nsUnicharStreamLoader.h"
#include "nsDownloader.h"
@ -75,6 +71,27 @@
///////////////////////////////////////////////////////////////////////////////
#include "nsIOService.h"
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsIOService, Init)
#include "nsStreamTransportService.h"
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsStreamTransportService, Init)
#include "nsSocketTransportService2.h"
#undef LOG
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsSocketTransportService, Init)
#include "nsAsyncStreamCopier.h"
NS_GENERIC_FACTORY_CONSTRUCTOR(nsAsyncStreamCopier)
#include "nsInputStreamPump.h"
NS_GENERIC_FACTORY_CONSTRUCTOR(nsInputStreamPump)
#include "nsInputStreamChannel.h"
NS_GENERIC_FACTORY_CONSTRUCTOR(nsInputStreamChannel)
///////////////////////////////////////////////////////////////////////////////
#include "nsStreamConverterService.h"
#ifdef BUILD_APPLEFILE_DECODER
@ -91,18 +108,12 @@ NS_GENERIC_FACTORY_CONSTRUCTOR(nsMIMEInfoImpl)
///////////////////////////////////////////////////////////////////////////////
#include "nsRequestObserverProxy.h"
#include "nsStreamListenerProxy.h"
#include "nsStreamProviderProxy.h"
#include "nsSimpleStreamListener.h"
#include "nsSimpleStreamProvider.h"
#include "nsDirIndexParser.h"
#include "nsDirIndex.h"
NS_GENERIC_FACTORY_CONSTRUCTOR(nsRequestObserverProxy)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsStreamListenerProxy)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsStreamProviderProxy)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsSimpleStreamListener)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsSimpleStreamProvider)
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsDirIndexParser, Init)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsDirIndex)
@ -113,15 +124,10 @@ NS_GENERIC_FACTORY_CONSTRUCTOR(nsStreamListenerTee)
///////////////////////////////////////////////////////////////////////////////
#include "nsStorageTransport.h"
NS_GENERIC_FACTORY_CONSTRUCTOR(nsStorageTransport)
///////////////////////////////////////////////////////////////////////////////
#include "nsHttpHandler.h"
#include "nsHttpBasicAuth.h"
#include "nsHttpDigestAuth.h"
#undef LOG
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsHttpHandler, Init)
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsHttpsHandler, Init)
@ -160,10 +166,13 @@ NS_GENERIC_FACTORY_CONSTRUCTOR(nsIDNService)
///////////////////////////////////////////////////////////////////////////////
#include "nsFileChannel.h"
#include "nsFileProtocolHandler.h"
#include "nsDataHandler.h"
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsFileProtocolHandler, Init)
#include "nsJARProtocolHandler.h"
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsJARProtocolHandler, Init)
#include "nsDataHandler.h"
#include "nsAboutProtocolHandler.h"
#include "nsAboutBlank.h"
@ -515,15 +524,15 @@ static const nsModuleComponentInfo gNetModuleInfo[] = {
{ NS_IOSERVICE_CLASSNAME,
NS_IOSERVICE_CID,
NS_IOSERVICE_CONTRACTID,
nsIOService::Create },
{ "File Transport Service",
NS_FILETRANSPORTSERVICE_CID,
"@mozilla.org/network/file-transport-service;1",
nsFileTransportService::Create },
{ "Socket Transport Service",
nsIOServiceConstructor },
{ NS_STREAMTRANSPORTSERVICE_CLASSNAME,
NS_STREAMTRANSPORTSERVICE_CID,
NS_STREAMTRANSPORTSERVICE_CONTRACTID,
nsStreamTransportServiceConstructor },
{ NS_SOCKETTRANSPORTSERVICE_CLASSNAME,
NS_SOCKETTRANSPORTSERVICE_CID,
"@mozilla.org/network/socket-transport-service;1",
nsSocketTransportService::Create },
NS_SOCKETTRANSPORTSERVICE_CONTRACTID,
nsSocketTransportServiceConstructor },
{ "Socket Provider Service",
NS_SOCKETPROVIDERSERVICE_CID,
"@mozilla.org/network/socket-provider-service;1",
@ -544,18 +553,18 @@ static const nsModuleComponentInfo gNetModuleInfo[] = {
NS_NETMODULEMGR_CID,
"@mozilla.org/network/net-extern-mod;1",
nsNetModuleMgr::Create },
{ NS_FILEIO_CLASSNAME,
NS_FILEIO_CID,
NS_FILEIO_CONTRACTID,
nsFileIO::Create },
{ NS_INPUTSTREAMIO_CLASSNAME,
NS_INPUTSTREAMIO_CID,
NS_INPUTSTREAMIO_CONTRACTID,
nsInputStreamIO::Create },
{ NS_STREAMIOCHANNEL_CLASSNAME,
NS_STREAMIOCHANNEL_CID,
NS_STREAMIOCHANNEL_CONTRACTID,
nsStreamIOChannel::Create },
{ NS_ASYNCSTREAMCOPIER_CLASSNAME,
NS_ASYNCSTREAMCOPIER_CID,
NS_ASYNCSTREAMCOPIER_CONTRACTID,
nsAsyncStreamCopierConstructor },
{ NS_INPUTSTREAMPUMP_CLASSNAME,
NS_INPUTSTREAMPUMP_CID,
NS_INPUTSTREAMPUMP_CONTRACTID,
nsInputStreamPumpConstructor },
{ NS_INPUTSTREAMCHANNEL_CLASSNAME,
NS_INPUTSTREAMCHANNEL_CID,
NS_INPUTSTREAMCHANNEL_CONTRACTID,
nsInputStreamChannelConstructor },
{ NS_STREAMLOADER_CLASSNAME,
NS_STREAMLOADER_CID,
NS_STREAMLOADER_CONTRACTID,
@ -572,22 +581,10 @@ static const nsModuleComponentInfo gNetModuleInfo[] = {
NS_REQUESTOBSERVERPROXY_CID,
NS_REQUESTOBSERVERPROXY_CONTRACTID,
nsRequestObserverProxyConstructor },
{ NS_STREAMLISTENERPROXY_CLASSNAME,
NS_STREAMLISTENERPROXY_CID,
NS_STREAMLISTENERPROXY_CONTRACTID,
nsStreamListenerProxyConstructor },
{ NS_STREAMPROVIDERPROXY_CLASSNAME,
NS_STREAMPROVIDERPROXY_CID,
NS_STREAMPROVIDERPROXY_CONTRACTID,
nsStreamProviderProxyConstructor },
{ NS_SIMPLESTREAMLISTENER_CLASSNAME,
NS_SIMPLESTREAMLISTENER_CID,
NS_SIMPLESTREAMLISTENER_CONTRACTID,
nsSimpleStreamListenerConstructor },
{ NS_SIMPLESTREAMPROVIDER_CLASSNAME,
NS_SIMPLESTREAMPROVIDER_CID,
NS_SIMPLESTREAMPROVIDER_CONTRACTID,
nsSimpleStreamProviderConstructor },
{ NS_ASYNCSTREAMLISTENER_CLASSNAME,
NS_ASYNCSTREAMLISTENER_CID,
NS_ASYNCSTREAMLISTENER_CONTRACTID,
@ -596,10 +593,6 @@ static const nsModuleComponentInfo gNetModuleInfo[] = {
NS_STREAMLISTENERTEE_CID,
NS_STREAMLISTENERTEE_CONTRACTID,
nsStreamListenerTeeConstructor },
{ NS_STORAGETRANSPORT_CLASSNAME,
NS_STORAGETRANSPORT_CID,
NS_STORAGETRANSPORT_CONTRACTID,
nsStorageTransportConstructor },
{ NS_LOADGROUP_CLASSNAME,
NS_LOADGROUP_CID,
NS_LOADGROUP_CONTRACTID,
@ -786,12 +779,6 @@ static const nsModuleComponentInfo gNetModuleInfo[] = {
nsDirIndexConstructor
},
#if defined(OLD_CACHE)
// from netwerk/cache:
{ "Memory Cache", NS_MEM_CACHE_FACTORY_CID, NS_NETWORK_MEMORY_CACHE_CONTRACTID, nsMemCacheConstructor },
{ "File Cache", NS_NETDISKCACHE_CID, NS_NETWORK_FILE_CACHE_CONTRACTID, nsNetDiskCacheConstructor },
{ "Cache Manager",NS_CACHE_MANAGER_CID, NS_NETWORK_CACHE_MANAGER_CONTRACTID,nsCacheManagerConstructor },
#endif
// from netwerk/mime:
{ "xml mime INFO",
NS_MIMEINFO_CID,
@ -800,15 +787,10 @@ static const nsModuleComponentInfo gNetModuleInfo[] = {
},
// from netwerk/protocol/file:
{ "File Protocol Handler",
{ NS_FILEPROTOCOLHANDLER_CLASSNAME,
NS_FILEPROTOCOLHANDLER_CID,
NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "file",
nsFileProtocolHandler::Create
},
{ NS_LOCALFILECHANNEL_CLASSNAME,
NS_LOCALFILECHANNEL_CID,
NS_LOCALFILECHANNEL_CONTRACTID,
nsFileChannel::Create
nsFileProtocolHandlerConstructor
},
{ "HTTP Handler",
@ -839,20 +821,20 @@ static const nsModuleComponentInfo gNetModuleInfo[] = {
},
// from netwerk/protocol/data:
{ "Data Protocol Handler",
NS_DATAHANDLER_CID,
{ NS_DATAPROTOCOLHANDLER_CLASSNAME,
NS_DATAPROTOCOLHANDLER_CID,
NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "data",
nsDataHandler::Create},
// from netwerk/protocol/jar:
{ "JAR Protocol Handler",
NS_JARPROTOCOLHANDLER_CID,
NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "jar",
nsJARProtocolHandler::Create
{ NS_JARPROTOCOLHANDLER_CLASSNAME,
NS_JARPROTOCOLHANDLER_CID,
NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "jar",
nsJARProtocolHandlerConstructor
},
// from netwerk/protocol/res:
{ "Resource Protocol Handler",
{ NS_RESPROTOCOLHANDLER_CLASSNAME,
NS_RESPROTOCOLHANDLER_CID,
NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "resource",
nsResProtocolHandlerConstructor
@ -899,6 +881,7 @@ static const nsModuleComponentInfo gNetModuleInfo[] = {
NS_ABOUT_MODULE_CONTRACTID_PREFIX "logo",
nsAboutRedirector::Create
},
{ "about:cache",
NS_ABOUT_CACHE_MODULE_CID,
NS_ABOUT_MODULE_CONTRACTID_PREFIX "cache",
@ -909,6 +892,7 @@ static const nsModuleComponentInfo gNetModuleInfo[] = {
NS_ABOUT_MODULE_CONTRACTID_PREFIX "cache-entry",
nsAboutCacheEntryConstructor
},
// from netwerk/protocol/keyword:
{ "The Keyword Protocol Handler",
NS_KEYWORDPROTOCOLHANDLER_CID,

5
netwerk/cache/Makefile.in поставляемый
Просмотреть файл

@ -26,10 +26,7 @@ VPATH = @srcdir@
include $(DEPTH)/config/autoconf.mk
DIRS = \
public \
src \
$(NULL)
DIRS = public src
include $(topsrcdir)/config/rules.mk

32
netwerk/cache/public/nsICacheEntryDescriptor.idl поставляемый
Просмотреть файл

@ -29,7 +29,8 @@
interface nsISimpleEnumerator;
interface nsICacheListener;
interface nsITransport;
interface nsIInputStream;
interface nsIOutputStream;
interface nsIFile;
interface nsICacheMetaDataVisitor;
@ -50,10 +51,33 @@ interface nsICacheEntryDescriptor : nsICacheEntryInfo
void setDataSize(in unsigned long size);
/**
* Get a transport to the cache data. This will fail if the cache entry
* IS NOT stream based.
* Open blocking input stream to cache data. This will fail if the cache
* entry IS NOT stream based. Use the stream transport service to
* asynchronously read this stream on a background thread. The returned
* stream MAY implement nsISeekableStream.
*
* @param offset
* read starting from this offset into the cached data.
*
* @return blocking, unbuffered input stream.
*/
readonly attribute nsITransport transport;
nsIInputStream openInputStream(in unsigned long offset);
/**
* Open blocking output stream to cache data. This will fail if the cache
* entry IS NOT stream based. Use the stream transport service to
* asynchronously write to this stream on a background thread. The returned
* stream MAY implement nsISeekableStream.
*
* If opening an output stream to existing cached data, the data will be
* truncated to the specified offset.
*
* @param offset
* write starting from this offset into the cached data.
*
* @return blocking, unbuffered output stream.
*/
nsIOutputStream openOutputStream(in unsigned long offset);
/**
* Get/set the cache data element. This will fail if the cache entry

2
netwerk/cache/src/Makefile.in поставляемый
Просмотреть файл

@ -48,13 +48,13 @@ CPPSRCS = \
nsCacheMetaData.cpp \
nsCacheService.cpp \
nsCacheSession.cpp \
nsMemoryCacheDevice.cpp \
nsDiskCacheBinding.cpp \
nsDiskCacheBlockFile.cpp \
nsDiskCacheDevice.cpp \
nsDiskCacheEntry.cpp \
nsDiskCacheMap.cpp \
nsDiskCacheStreams.cpp \
nsMemoryCacheDevice.cpp \
$(NULL)
include $(topsrcdir)/config/config.mk

15
netwerk/cache/src/nsCacheDevice.h поставляемый
Просмотреть файл

@ -32,7 +32,8 @@ class nsIFile;
class nsCString;
class nsCacheEntry;
class nsICacheVisitor;
class nsITransport;
class nsIInputStream;
class nsIOutputStream;
/******************************************************************************
* nsCacheDevice
@ -52,9 +53,15 @@ public:
virtual nsresult BindEntry( nsCacheEntry * entry ) = 0;
virtual void DoomEntry( nsCacheEntry * entry ) = 0;
virtual nsresult GetTransportForEntry( nsCacheEntry * entry,
nsCacheAccessMode mode,
nsITransport **result ) = 0;
virtual nsresult OpenInputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIInputStream ** result) = 0;
virtual nsresult OpenOutputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIOutputStream ** result) = 0;
virtual nsresult GetFileForEntry( nsCacheEntry * entry,
nsIFile ** result ) = 0;

390
netwerk/cache/src/nsCacheEntryDescriptor.cpp поставляемый
Просмотреть файл

@ -233,14 +233,48 @@ nsCacheEntryDescriptor::SetDataSize(PRUint32 dataSize)
NS_IMETHODIMP
nsCacheEntryDescriptor::GetTransport(nsITransport ** result)
nsCacheEntryDescriptor::OpenInputStream(PRUint32 offset, nsIInputStream ** result)
{
NS_ENSURE_ARG_POINTER(result);
nsAutoLock lock(nsCacheService::ServiceLock());
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
if (!mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_NOT_STREAM;
NS_ADDREF(*result = &mTransportWrapper);
{
nsAutoLock lock(nsCacheService::ServiceLock());
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
if (!mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_NOT_STREAM;
// ensure valid permissions
if (!(mAccessGranted & nsICache::ACCESS_READ))
return NS_ERROR_CACHE_READ_ACCESS_DENIED;
}
nsInputStreamWrapper* cacheInput =
new nsInputStreamWrapper(this, offset);
if (!cacheInput) return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(*result = cacheInput);
return NS_OK;
}
NS_IMETHODIMP
nsCacheEntryDescriptor::OpenOutputStream(PRUint32 offset, nsIOutputStream ** result)
{
NS_ENSURE_ARG_POINTER(result);
{
nsAutoLock lock(nsCacheService::ServiceLock());
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
if (!mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_NOT_STREAM;
// ensure valid permissions
if (!(mAccessGranted & nsICache::ACCESS_WRITE))
return NS_ERROR_CACHE_WRITE_ACCESS_DENIED;
}
nsOutputStreamWrapper* cacheOutput =
new nsOutputStreamWrapper(this, offset);
if (!cacheOutput) return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(*result = cacheOutput);
return NS_OK;
}
@ -438,259 +472,122 @@ nsCacheEntryDescriptor::VisitMetaData(nsICacheMetaDataVisitor * visitor)
/******************************************************************************
* nsCacheTransportWrapper
* nsCacheInputStream - a wrapper for nsIInputstream keeps the cache entry
* open while referenced.
******************************************************************************/
NS_IMPL_QUERY_INTERFACE1(nsCacheEntryDescriptor::nsTransportWrapper, nsITransport)
// special AddRef and Release, because we are part of the descriptor
#define GET_DESCRIPTOR_FROM_TRANSPORT_WRAPPER(_this) \
((nsCacheEntryDescriptor*)((char*)(_this) - \
offsetof(nsCacheEntryDescriptor, mTransportWrapper)))
NS_IMETHODIMP_(nsrefcnt) nsCacheEntryDescriptor::
nsTransportWrapper::AddRef(void)
{
return GET_DESCRIPTOR_FROM_TRANSPORT_WRAPPER(this)->AddRef();
}
NS_IMETHODIMP_(nsrefcnt) nsCacheEntryDescriptor::
nsTransportWrapper::Release(void)
{
return GET_DESCRIPTOR_FROM_TRANSPORT_WRAPPER(this)->Release();
}
NS_IMPL_THREADSAFE_ISUPPORTS1(nsCacheEntryDescriptor::nsInputStreamWrapper,
nsIInputStream)
nsresult nsCacheEntryDescriptor::
nsTransportWrapper::EnsureTransportWithAccess(nsCacheAccessMode mode)
nsInputStreamWrapper::LazyInit()
{
nsresult rv = NS_OK;
nsAutoLock lock(nsCacheService::ServiceLock());
nsCacheEntryDescriptor * descriptor = GET_DESCRIPTOR_FROM_TRANSPORT_WRAPPER(this);
nsAutoLock lock(nsCacheService::ServiceLock());
if (!descriptor->mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
if (!descriptor->mAccessGranted & mode) {
rv = (mode == nsICache::ACCESS_READ) ?
NS_ERROR_CACHE_READ_ACCESS_DENIED : NS_ERROR_CACHE_WRITE_ACCESS_DENIED;
return rv;
}
if (!mTransport) {
rv = nsCacheService::GetTransportForEntry(descriptor->mCacheEntry,
descriptor->mAccessGranted,
getter_AddRefs(mTransport));
if (NS_FAILED(rv)) return rv;
if (mCallbacks) {
mTransport->SetNotificationCallbacks(mCallbacks, mCallbackFlags);
}
}
return NS_OK;
}
nsresult
nsCacheEntryDescriptor::NewOutputStreamWrapper(nsIOutputStream ** result,
nsCacheEntryDescriptor * descriptor,
nsIOutputStream * output)
{
nsOutputStreamWrapper* cacheOutput =
new nsOutputStreamWrapper(descriptor, output);
if (!cacheOutput) return NS_ERROR_OUT_OF_MEMORY;
nsCOMPtr<nsISupports> ref(cacheOutput);
nsresult rv = cacheOutput->Init();
nsCacheAccessMode mode;
nsresult rv = mDescriptor->GetAccessGranted(&mode);
if (NS_FAILED(rv)) return rv;
NS_ADDREF(*result = cacheOutput);
NS_ENSURE_TRUE(mode & nsICache::ACCESS_READ, NS_ERROR_UNEXPECTED);
nsCacheEntry* cacheEntry = mDescriptor->CacheEntry();
if (!cacheEntry) return NS_ERROR_NOT_AVAILABLE;
nsCOMPtr<nsIInputStream> input;
rv = nsCacheService::OpenInputStreamForEntry(cacheEntry, mode,
mStartOffset,
getter_AddRefs(mInput));
if (NS_FAILED(rv)) return rv;
mInitialized = PR_TRUE;
return NS_OK;
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsTransportWrapper::GetSecurityInfo(nsISupports ** securityInfo)
nsresult nsCacheEntryDescriptor::
nsInputStreamWrapper::Close()
{
nsresult rv = EnsureInit();
if (NS_FAILED(rv)) return rv;
return mInput->Close();
}
nsresult nsCacheEntryDescriptor::
nsInputStreamWrapper::Available(PRUint32 *avail)
{
nsresult rv = EnsureInit();
if (NS_FAILED(rv)) return rv;
return mInput->Available(avail);
}
nsresult nsCacheEntryDescriptor::
nsInputStreamWrapper::Read(char *buf, PRUint32 count, PRUint32 *countRead)
{
nsresult rv = EnsureInit();
if (NS_FAILED(rv)) return rv;
return mInput->Read(buf, count, countRead);
}
nsresult nsCacheEntryDescriptor::
nsInputStreamWrapper::ReadSegments(nsWriteSegmentFun writer, void *closure,
PRUint32 count, PRUint32 *countRead)
{
NS_NOTREACHED("cache stream not buffered");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsTransportWrapper::GetNotificationCallbacks(nsIInterfaceRequestor **result)
nsresult nsCacheEntryDescriptor::
nsInputStreamWrapper::IsNonBlocking(PRBool *result)
{
NS_ENSURE_ARG_POINTER(result);
*result = mCallbacks;
NS_IF_ADDREF(*result);
// cache streams will never return NS_BASE_STREAM_WOULD_BLOCK
*result = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsTransportWrapper::SetNotificationCallbacks(nsIInterfaceRequestor *requestor,
PRUint32 flags)
{
if (mTransport) {
mTransport->SetNotificationCallbacks(requestor, flags);
}
mCallbacks = requestor;
mCallbackFlags = flags;
return NS_OK;;
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsTransportWrapper::OpenInputStream(PRUint32 offset,
PRUint32 count,
PRUint32 flags,
nsIInputStream ** result)
{
NS_ENSURE_ARG_POINTER(result);
nsresult rv = EnsureTransportWithAccess(nsICache::ACCESS_READ);
if (NS_FAILED(rv)) return rv;
return mTransport->OpenInputStream(offset, count, flags, result);
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsTransportWrapper::OpenOutputStream(PRUint32 offset,
PRUint32 count,
PRUint32 flags,
nsIOutputStream ** result)
{
NS_ENSURE_ARG_POINTER(result);
nsresult rv = EnsureTransportWithAccess(nsICache::ACCESS_WRITE);
if (NS_FAILED(rv)) return rv;
// Create the underlying output stream using the wrapped transport.
nsCOMPtr<nsIOutputStream> output;
rv = mTransport->OpenOutputStream(offset, count, flags, getter_AddRefs(output));
if (NS_FAILED(rv)) return rv;
// Wrap this output stream with a stream that monitors how much data gets written,
// maintains the cache entry's size, and informs the cache device.
// This mechanism provides a way for the cache device to enforce space limits,
// and to drive cache entry eviction.
nsCacheEntryDescriptor * descriptor = GET_DESCRIPTOR_FROM_TRANSPORT_WRAPPER(this);
// reset datasize of entry based on offset so OnWrite calculates delta changes correctly.
rv = descriptor->SetDataSize(offset);
if (NS_FAILED(rv)) return rv;
return NewOutputStreamWrapper(result, descriptor, output);
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsTransportWrapper::AsyncRead(nsIStreamListener * listener,
nsISupports * ctxt,
PRUint32 offset,
PRUint32 count,
PRUint32 flags,
nsIRequest ** result)
{
NS_ENSURE_ARG_POINTER(result);
nsresult rv = EnsureTransportWithAccess(nsICache::ACCESS_READ);
if (NS_FAILED(rv)) return rv;
return mTransport->AsyncRead(listener, ctxt, offset, count, flags, result);
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsTransportWrapper::AsyncWrite(nsIStreamProvider * provider,
nsISupports * ctxt,
PRUint32 offset,
PRUint32 count,
PRUint32 flags,
nsIRequest ** result)
{
// we're not planning on implementing this
return NS_ERROR_NOT_IMPLEMENTED;
#if 0
NS_ENSURE_ARG_POINTER(result);
nsresult rv = EnsureTransportWithAccess(nsICache::ACCESS_WRITE);
if (NS_FAILED(rv)) return rv;
return mTransport->AsyncWrite(provider, ctxt, offset, count, flags, result);
#endif
}
/******************************************************************************
* nsCacheOutputStream - a wrapper for nsIOutputstream to track the amount of
* data written to a cache entry.
* - also keeps the cache entry open while referenced.
******************************************************************************/
NS_IMPL_ISUPPORTS1(nsCacheEntryDescriptor::nsOutputStreamWrapper, nsIOutputStream);
NS_IMPL_THREADSAFE_ISUPPORTS1(nsCacheEntryDescriptor::nsOutputStreamWrapper,
nsIOutputStream)
nsresult nsCacheEntryDescriptor::
nsOutputStreamWrapper::Init()
nsOutputStreamWrapper::LazyInit()
{
nsAutoLock lock(nsCacheService::ServiceLock());
nsCacheAccessMode mode;
nsresult rv = mDescriptor->GetAccessGranted(&mode);
if (NS_FAILED(rv)) return rv;
if (mode == nsICache::ACCESS_WRITE) {
nsAutoLock lock(nsCacheService::ServiceLock());
nsCacheEntry* cacheEntry = mDescriptor->CacheEntry();
if (!cacheEntry) return NS_ERROR_NOT_AVAILABLE;
NS_ENSURE_TRUE(mode & nsICache::ACCESS_WRITE, NS_ERROR_UNEXPECTED);
nsCacheDevice* device = cacheEntry->CacheDevice();
if (!device) return NS_ERROR_NOT_AVAILABLE;
nsCacheEntry* cacheEntry = mDescriptor->CacheEntry();
if (!cacheEntry) return NS_ERROR_NOT_AVAILABLE;
// the entry has been truncated to zero bytes, inform the device.
PRInt32 delta = cacheEntry->DataSize();
rv = device->OnDataSizeChange(cacheEntry, -delta);
cacheEntry->SetDataSize(0);
}
return rv;
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsOutputStreamWrapper::Write(const char * buf,
PRUint32 count,
PRUint32 * result)
{
nsresult rv = OnWrite(count);
rv = nsCacheService::OpenOutputStreamForEntry(cacheEntry, mode, mStartOffset,
getter_AddRefs(mOutput));
if (NS_FAILED(rv)) return rv;
return mOutput->Write(buf, count, result);
}
nsCacheDevice* device = cacheEntry->CacheDevice();
if (!device) return NS_ERROR_NOT_AVAILABLE;
NS_IMETHODIMP nsCacheEntryDescriptor::
nsOutputStreamWrapper::WriteFrom(nsIInputStream * inStr,
PRUint32 count,
PRUint32 * result)
{
nsresult rv = OnWrite(count);
// the entry has been truncated to mStartOffset bytes, inform the device.
PRInt32 size = cacheEntry->DataSize();
rv = device->OnDataSizeChange(cacheEntry, mStartOffset - size);
if (NS_FAILED(rv)) return rv;
return mOutput->WriteFrom(inStr, count, result);
cacheEntry->SetDataSize(mStartOffset);
mInitialized = PR_TRUE;
return NS_OK;
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsOutputStreamWrapper::WriteSegments(nsReadSegmentFun reader,
void * closure,
PRUint32 count,
PRUint32 * result)
{
nsresult rv = OnWrite(count);
if (NS_FAILED(rv)) return rv;
return mOutput->WriteSegments(reader, closure, count, result);
}
nsresult nsCacheEntryDescriptor::
nsOutputStreamWrapper::OnWrite(PRUint32 count)
{
@ -698,4 +595,61 @@ nsOutputStreamWrapper::OnWrite(PRUint32 count)
return mDescriptor->RequestDataSizeChange((PRInt32)count);
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsOutputStreamWrapper::Close()
{
nsresult rv = EnsureInit();
if (NS_FAILED(rv)) return rv;
return mOutput->Close();
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsOutputStreamWrapper::Flush()
{
nsresult rv = EnsureInit();
if (NS_FAILED(rv)) return rv;
return mOutput->Flush();
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsOutputStreamWrapper::Write(const char * buf,
PRUint32 count,
PRUint32 * result)
{
nsresult rv = EnsureInit();
if (NS_FAILED(rv)) return rv;
rv = OnWrite(count);
if (NS_FAILED(rv)) return rv;
return mOutput->Write(buf, count, result);
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsOutputStreamWrapper::WriteFrom(nsIInputStream * inStr,
PRUint32 count,
PRUint32 * result)
{
NS_NOTREACHED("cache stream not buffered");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsOutputStreamWrapper::WriteSegments(nsReadSegmentFun reader,
void * closure,
PRUint32 count,
PRUint32 * result)
{
NS_NOTREACHED("cache stream not buffered");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsCacheEntryDescriptor::
nsOutputStreamWrapper::IsNonBlocking(PRBool *result)
{
// cache streams will never return NS_BASE_STREAM_WOULD_BLOCK
*result = PR_FALSE;
return NS_OK;
}

107
netwerk/cache/src/nsCacheEntryDescriptor.h поставляемый
Просмотреть файл

@ -27,10 +27,8 @@
#include "nsICacheEntryDescriptor.h"
#include "nsCacheEntry.h"
#include "nsIInputStream.h"
#include "nsIOutputStream.h"
#include "nsITransport.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
/******************************************************************************
* nsCacheEntryDescriptor
@ -64,98 +62,85 @@ public:
private:
/*************************************************************************
* transport wrapper class -
* input stream wrapper class -
*
* we want the transport wrapper to have the same lifetime as the
* descriptor, but since they each need to reference the other, we have the
* descriptor include the transport wrapper as a member, rather than just
* pointing to it, which avoids circular AddRefs.
* The input stream wrapper references the descriptor, but the descriptor
* doesn't need any references to the stream wrapper.
*************************************************************************/
class nsTransportWrapper : public nsITransport
{
class nsInputStreamWrapper : public nsIInputStream {
private:
nsCacheEntryDescriptor * mDescriptor;
nsCOMPtr<nsIInputStream> mInput;
PRUint32 mStartOffset;
PRBool mInitialized;
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSITRANSPORT
NS_DECL_ISUPPORTS
NS_DECL_NSIINPUTSTREAM
nsTransportWrapper() : mCallbackFlags(0) {}
virtual ~nsTransportWrapper() {}
nsInputStreamWrapper(nsCacheEntryDescriptor * desc, PRUint32 off)
: mDescriptor(desc)
, mStartOffset(off)
, mInitialized(PR_FALSE)
{
NS_ADDREF(mDescriptor);
}
virtual ~nsInputStreamWrapper()
{
NS_RELEASE(mDescriptor);
}
nsresult EnsureTransportWithAccess(nsCacheAccessMode mode);
PRUint32 mCallbackFlags;
nsCOMPtr<nsITransport> mTransport;
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
}; // end of class nsTransportWrapper
friend class nsTransportWrapper;
private:
nsresult LazyInit();
nsresult EnsureInit() { return mInitialized ? NS_OK : LazyInit(); }
};
friend class nsInputStreamWrapper;
/*************************************************************************
* output stream wrapper class -
*
* The output stream wrapper references the descriptor, but the descriptor
* doesn't need any references to the stream wrapper, so we don't need the
* same kind of tricks that we're using for the transport wrapper.
* doesn't need any references to the stream wrapper.
*************************************************************************/
class nsOutputStreamWrapper : public nsIOutputStream {
private:
nsCacheEntryDescriptor * mDescriptor;
nsCOMPtr<nsIOutputStream> mOutput;
nsCacheEntryDescriptor * mDescriptor;
nsCOMPtr<nsIOutputStream> mOutput;
PRUint32 mStartOffset;
PRBool mInitialized;
public:
NS_DECL_ISUPPORTS
// NS_DECL_NSIOUTPUTSTREAM
NS_IMETHOD Close(void) { return mOutput->Close(); }
NS_IMETHOD Flush(void) { return mOutput->Flush(); }
NS_DECL_NSIOUTPUTSTREAM
NS_IMETHOD Write(const char * buf,
PRUint32 count,
PRUint32 * result);
NS_IMETHOD WriteFrom(nsIInputStream * inStr,
PRUint32 count,
PRUint32 * result);
NS_IMETHOD WriteSegments(nsReadSegmentFun reader,
void * closure,
PRUint32 count,
PRUint32 * result);
NS_IMETHOD IsNonBlocking(PRBool * nonBlocking)
{ return mOutput->IsNonBlocking(nonBlocking); }
nsOutputStreamWrapper(nsCacheEntryDescriptor * descriptor,
nsIOutputStream * output)
: mDescriptor(nsnull), mOutput(output)
nsOutputStreamWrapper(nsCacheEntryDescriptor * desc, PRUint32 off)
: mDescriptor(desc)
, mStartOffset(off)
, mInitialized(PR_FALSE)
{
NS_ADDREF(mDescriptor = descriptor);
NS_ADDREF(mDescriptor); // owning ref
}
virtual ~nsOutputStreamWrapper()
{
{
// XXX _HACK_ the storage stream needs this!
Close();
NS_RELEASE(mDescriptor);
}
nsresult Init();
private:
nsresult LazyInit();
nsresult EnsureInit() { return mInitialized ? NS_OK : LazyInit(); }
nsresult OnWrite(PRUint32 count);
}; // end of class nsOutputStreamWrapper
};
friend class nsOutputStreamWrapper;
static nsresult NewOutputStreamWrapper(nsIOutputStream ** result,
nsCacheEntryDescriptor * descriptor,
nsIOutputStream * output);
private:
/**
* nsCacheEntryDescriptor data members
*/
nsCacheEntry * mCacheEntry; // we are a child of the entry
nsCacheAccessMode mAccessGranted;
nsTransportWrapper mTransportWrapper;
};

22
netwerk/cache/src/nsCacheService.cpp поставляемый
Просмотреть файл

@ -40,6 +40,7 @@
#include "nsIPrefBranch.h"
#include "nsIPrefBranchInternal.h"
#include "nsIPref.h"
#include "nsILocalFile.h"
#include "nsDirectoryServiceDefs.h"
#include "nsAppDirectoryServiceDefs.h"
#include "nsVoidArray.h"
@ -1240,14 +1241,27 @@ nsCacheService::GetFileForEntry(nsCacheEntry * entry,
nsresult
nsCacheService::GetTransportForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
nsITransport ** result)
nsCacheService::OpenInputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIInputStream ** result)
{
nsCacheDevice * device = gService->EnsureEntryHasDevice(entry);
if (!device) return NS_ERROR_UNEXPECTED;
return device->GetTransportForEntry(entry, mode, result);
return device->OpenInputStreamForEntry(entry, mode, offset, result);
}
nsresult
nsCacheService::OpenOutputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIOutputStream ** result)
{
nsCacheDevice * device = gService->EnsureEntryHasDevice(entry);
if (!device) return NS_ERROR_UNEXPECTED;
return device->OpenOutputStreamForEntry(entry, mode, offset, result);
}

12
netwerk/cache/src/nsCacheService.h поставляемый
Просмотреть файл

@ -86,9 +86,15 @@ public:
static nsresult GetFileForEntry(nsCacheEntry * entry,
nsIFile ** result);
static nsresult GetTransportForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
nsITransport ** result);
static nsresult OpenInputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIInputStream ** result);
static nsresult OpenOutputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIOutputStream ** result);
static nsresult OnDataSizeChange(nsCacheEntry * entry, PRInt32 deltaSize);

19
netwerk/cache/src/nsDiskCacheBinding.cpp поставляемый
Просмотреть файл

@ -110,6 +110,7 @@ NS_IMPL_THREADSAFE_ISUPPORTS0(nsDiskCacheBinding);
nsDiskCacheBinding::nsDiskCacheBinding(nsCacheEntry* entry, nsDiskCacheRecord * record)
: mCacheEntry(entry)
, mStreamIO(nsnull)
{
NS_ASSERTION(record->ValidRecord(), "bad record");
PR_INIT_CLIST(this);
@ -125,9 +126,21 @@ nsDiskCacheBinding::~nsDiskCacheBinding()
PR_REMOVE_LINK(this); // XXX why are we still on a list?
// sever streamIO/binding link
// XXX what's the right way to call a method on the concrete class?
nsDiskCacheStreamIO * streamIO = (nsDiskCacheStreamIO *)mStreamIO.get();
if (streamIO) streamIO->ClearBinding();
if (mStreamIO) {
mStreamIO->ClearBinding();
NS_RELEASE(mStreamIO);
}
}
nsresult
nsDiskCacheBinding::EnsureStreamIO()
{
if (!mStreamIO) {
mStreamIO = new nsDiskCacheStreamIO(this);
if (!mStreamIO) return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(mStreamIO);
}
return NS_OK;
}

3
netwerk/cache/src/nsDiskCacheBinding.h поставляемый
Просмотреть файл

@ -52,12 +52,13 @@ public:
nsDiskCacheBinding(nsCacheEntry* entry, nsDiskCacheRecord * record);
virtual ~nsDiskCacheBinding();
nsresult EnsureStreamIO();
// XXX make friends
public:
nsCacheEntry* mCacheEntry; // back pointer to parent nsCacheEntry
nsDiskCacheRecord mRecord;
nsCOMPtr<nsIStreamIO> mStreamIO;
nsDiskCacheStreamIO* mStreamIO;
PRBool mDoomed; // record is not stored in cache map
PRUint8 mGeneration; // possibly just reservation
};

58
netwerk/cache/src/nsDiskCacheDevice.cpp поставляемый
Просмотреть файл

@ -55,8 +55,6 @@
#include "nsCacheService.h"
#include "nsCache.h"
#include "nsIFileTransportService.h"
#include "nsITransport.h"
#include "nsICacheVisitor.h"
#include "nsXPIDLString.h"
#include "nsReadableUtils.h"
@ -310,7 +308,6 @@ nsDiskCache::Truncate(PRFileDesc * fd, PRUint32 newEOF)
/******************************************************************************
* nsDiskCacheDevice
*****************************************************************************/
static nsCOMPtr<nsIFileTransportService> gFileTransportService;
#ifdef XP_MAC
#pragma mark -
@ -345,10 +342,6 @@ nsDiskCacheDevice::Init()
rv = mBindery.Init();
if (NS_FAILED(rv)) return rv;
// hold the file transport service to avoid excessive calls to the service manager.
gFileTransportService = do_GetService("@mozilla.org/network/file-transport-service;1", &rv);
if (NS_FAILED(rv)) return rv;
// XXX we should spawn another thread to do this after startup
// delete "Cache.Trash" folder
nsCOMPtr<nsIFile> cacheTrashDir;
@ -379,7 +372,6 @@ error_exit:
delete mCacheMap;
mCacheMap = nsnull;
}
gFileTransportService = nsnull;
return rv;
}
@ -405,9 +397,6 @@ nsDiskCacheDevice::Shutdown()
mInitialized = PR_FALSE;
}
// release the reference to the cached file transport service.
gFileTransportService = nsnull;
return NS_OK;
}
@ -596,33 +585,52 @@ nsDiskCacheDevice::DoomEntry(nsCacheEntry * entry)
}
}
/**
* NOTE: called while holding the cache service lock
*/
nsresult
nsDiskCacheDevice::GetTransportForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
nsITransport ** result)
nsDiskCacheDevice::OpenInputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIInputStream ** result)
{
NS_ENSURE_ARG_POINTER(entry);
NS_ENSURE_ARG_POINTER(result);
nsresult rv;
nsDiskCacheBinding * binding = GetCacheEntryBinding(entry);
NS_ASSERTION(binding, "GetTransportForEntry: binding == nsnull");
if (!binding) return NS_ERROR_UNEXPECTED;
NS_ENSURE_TRUE(binding, NS_ERROR_UNEXPECTED);
NS_ASSERTION(binding->mCacheEntry == entry, "binding & entry don't point to each other");
if (!binding->mStreamIO) {
binding->mStreamIO = new nsDiskCacheStreamIO(binding);
if (!binding->mStreamIO) return NS_ERROR_OUT_OF_MEMORY;
}
// XXX assumption: CreateTransportFromStreamIO() is light-weight
// PR_FALSE = keep streamIO open for lifetime of transport
rv = gFileTransportService->CreateTransportFromStreamIO(binding->mStreamIO, PR_FALSE, result);
return rv;
rv = binding->EnsureStreamIO();
if (NS_FAILED(rv)) return rv;
return binding->mStreamIO->GetInputStream(offset, result);
}
/**
* NOTE: called while holding the cache service lock
*/
nsresult
nsDiskCacheDevice::OpenOutputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIOutputStream ** result)
{
NS_ENSURE_ARG_POINTER(entry);
NS_ENSURE_ARG_POINTER(result);
nsresult rv;
nsDiskCacheBinding * binding = GetCacheEntryBinding(entry);
NS_ENSURE_TRUE(binding, NS_ERROR_UNEXPECTED);
NS_ASSERTION(binding->mCacheEntry == entry, "binding & entry don't point to each other");
rv = binding->EnsureStreamIO();
if (NS_FAILED(rv)) return rv;
return binding->mStreamIO->GetOutputStream(offset, result);
}

12
netwerk/cache/src/nsDiskCacheDevice.h поставляемый
Просмотреть файл

@ -52,9 +52,15 @@ public:
virtual nsresult BindEntry(nsCacheEntry * entry);
virtual void DoomEntry( nsCacheEntry * entry );
virtual nsresult GetTransportForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
nsITransport ** result);
virtual nsresult OpenInputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIInputStream ** result);
virtual nsresult OpenOutputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIOutputStream ** result);
virtual nsresult GetFileForEntry(nsCacheEntry * entry,
nsIFile ** result);

136
netwerk/cache/src/nsDiskCacheStreams.cpp поставляемый
Просмотреть файл

@ -29,7 +29,6 @@
#include "nsIInputStream.h"
#include "nsIOutputStream.h"
#include "nsISeekableStream.h"
#include "nsAutoLock.h"
@ -64,7 +63,7 @@ public:
private:
friend class nsDiskCacheStreamIO;
nsCOMPtr<nsDiskCacheStreamIO> mStreamIO; // backpointer to parent
nsDiskCacheStreamIO * mStreamIO; // backpointer to parent
PRFileDesc * mFD;
const char * mBuffer;
PRUint32 mStreamEnd;
@ -73,7 +72,7 @@ private:
};
NS_IMPL_THREADSAFE_ISUPPORTS1(nsDiskCacheInputStream, nsIInputStream);
NS_IMPL_THREADSAFE_ISUPPORTS1(nsDiskCacheInputStream, nsIInputStream)
nsDiskCacheInputStream::nsDiskCacheInputStream( nsDiskCacheStreamIO * parent,
@ -87,6 +86,7 @@ nsDiskCacheInputStream::nsDiskCacheInputStream( nsDiskCacheStreamIO * parent,
, mPos(0)
, mClosed(PR_FALSE)
{
NS_ADDREF(mStreamIO);
mStreamIO->IncrementInputStreamCount();
}
@ -95,6 +95,7 @@ nsDiskCacheInputStream::~nsDiskCacheInputStream()
{
Close();
mStreamIO->DecrementInputStreamCount();
NS_RELEASE(mStreamIO);
}
@ -182,37 +183,37 @@ nsDiskCacheInputStream::IsNonBlocking(PRBool * nonBlocking)
#pragma mark -
#pragma mark nsDiskCacheOutputStream
#endif
class nsDiskCacheOutputStream : public nsIOutputStream, nsISeekableStream {
class nsDiskCacheOutputStream : public nsIOutputStream {
public:
nsDiskCacheOutputStream( nsDiskCacheStreamIO * parent);
virtual ~nsDiskCacheOutputStream();
nsDiskCacheOutputStream( nsDiskCacheStreamIO * parent);
virtual ~nsDiskCacheOutputStream();
NS_DECL_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAM
NS_DECL_NSISEEKABLESTREAM
NS_DECL_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAM
private:
friend class nsDiskCacheStreamIO;
nsCOMPtr<nsDiskCacheStreamIO> mStreamIO; // backpointer to parent
nsDiskCacheStreamIO * mStreamIO; // backpointer to parent
PRBool mClosed;
};
NS_IMPL_THREADSAFE_ISUPPORTS2(nsDiskCacheOutputStream, nsIOutputStream, nsISeekableStream);
NS_IMPL_THREADSAFE_ISUPPORTS1(nsDiskCacheOutputStream,
nsIOutputStream)
nsDiskCacheOutputStream::nsDiskCacheOutputStream( nsDiskCacheStreamIO * parent)
: mStreamIO(parent)
, mClosed(PR_FALSE)
{
NS_ADDREF(mStreamIO);
}
nsDiskCacheOutputStream::~nsDiskCacheOutputStream()
{
Close();
NS_RELEASE(mStreamIO);
}
@ -264,30 +265,6 @@ nsDiskCacheOutputStream::WriteSegments( nsReadSegmentFun reader,
}
NS_IMETHODIMP
nsDiskCacheOutputStream::Seek(PRInt32 whence, PRInt32 offset)
{
if (mClosed) return NS_ERROR_NOT_AVAILABLE;
return mStreamIO->Seek(whence, offset);
}
NS_IMETHODIMP
nsDiskCacheOutputStream::Tell(PRUint32 * result)
{
if (mClosed) return NS_ERROR_NOT_AVAILABLE;
return mStreamIO->Tell(result);
}
NS_IMETHODIMP
nsDiskCacheOutputStream::SetEOF()
{
if (mClosed) return NS_ERROR_NOT_AVAILABLE;
return mStreamIO->SetEOF();
}
NS_IMETHODIMP
nsDiskCacheOutputStream::IsNonBlocking(PRBool * nonBlocking)
{
@ -305,7 +282,7 @@ nsDiskCacheOutputStream::IsNonBlocking(PRBool * nonBlocking)
#pragma mark nsDiskCacheStreamIO
#endif
NS_IMPL_THREADSAFE_ISUPPORTS1(nsDiskCacheStreamIO, nsIStreamIO);
NS_IMPL_THREADSAFE_ISUPPORTS0(nsDiskCacheStreamIO)
// we pick 16k as the max buffer size because that is the threshold above which
// we are unable to store the data in the cache block files
@ -335,7 +312,7 @@ nsDiskCacheStreamIO::nsDiskCacheStreamIO(nsDiskCacheBinding * binding)
nsDiskCacheStreamIO::~nsDiskCacheStreamIO()
{
(void) Close(NS_OK);
Close();
// release "death grip" on cache service
nsCacheService *service = nsCacheService::GlobalInstance();
@ -343,15 +320,8 @@ nsDiskCacheStreamIO::~nsDiskCacheStreamIO()
}
NS_IMETHODIMP
nsDiskCacheStreamIO::Open()
{
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheStreamIO::Close(nsresult status)
void
nsDiskCacheStreamIO::Close()
{
// this should only be called from our destructor
// no one is interested in us anymore, so we don't need to grab any locks
@ -362,18 +332,18 @@ nsDiskCacheStreamIO::Close(nsresult status)
NS_ASSERTION(!mFD, "file descriptor not closed");
DeleteBuffer();
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheStreamIO::GetInputStream(nsIInputStream ** inputStream)
// NOTE: called with service lock held
nsresult
nsDiskCacheStreamIO::GetInputStream(PRUint32 offset, nsIInputStream ** inputStream)
{
NS_ENSURE_ARG_POINTER(inputStream);
NS_ENSURE_TRUE(offset == 0, NS_ERROR_NOT_IMPLEMENTED);
*inputStream = nsnull;
nsAutoLock lock(nsCacheService::ServiceLock()); // grab service lock
if (!mBinding) return NS_ERROR_NOT_AVAILABLE;
if (mOutStream) {
@ -413,13 +383,13 @@ nsDiskCacheStreamIO::GetInputStream(nsIInputStream ** inputStream)
}
NS_IMETHODIMP
nsDiskCacheStreamIO::GetOutputStream(nsIOutputStream ** outputStream)
// NOTE: called with service lock held
nsresult
nsDiskCacheStreamIO::GetOutputStream(PRUint32 offset, nsIOutputStream ** outputStream)
{
NS_ENSURE_ARG_POINTER(outputStream);
*outputStream = nsnull;
nsAutoLock lock(nsCacheService::ServiceLock()); // grab service lock
if (!mBinding) return NS_ERROR_NOT_AVAILABLE;
NS_ASSERTION(!mOutStream, "already have an output stream open");
@ -432,6 +402,14 @@ nsDiskCacheStreamIO::GetOutputStream(nsIOutputStream ** outputStream)
mStreamPos = 0;
mStreamEnd = mBinding->mCacheEntry->DataSize();
nsresult rv;
if (offset) {
rv = Seek(PR_SEEK_SET, offset);
if (NS_FAILED(rv)) return rv;
}
rv = SetEOF();
if (NS_FAILED(rv)) return rv;
// create a new output stream
mOutStream = new nsDiskCacheOutputStream(this);
if (!mOutStream) return NS_ERROR_OUT_OF_MEMORY;
@ -440,40 +418,6 @@ nsDiskCacheStreamIO::GetOutputStream(nsIOutputStream ** outputStream)
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheStreamIO::GetName(nsACString & name)
{
name = NS_LITERAL_CSTRING("nsDiskCacheStreamIO");
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheStreamIO::GetContentType(nsACString & contentType)
{
contentType.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheStreamIO::GetContentCharset(nsACString & contentCharset)
{
contentCharset.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsDiskCacheStreamIO::GetContentLength(PRInt32 *contentLength)
{
NS_ENSURE_ARG_POINTER(contentLength);
*contentLength = -1;
return NS_OK;
}
void
nsDiskCacheStreamIO::ClearBinding()
{
@ -799,12 +743,12 @@ nsDiskCacheStreamIO::DeleteBuffer()
}
// called only from nsDiskCacheOutputStream::Seek
// NOTE: called with service lock held
nsresult
nsDiskCacheStreamIO::Seek(PRInt32 whence, PRInt32 offset)
{
PRInt32 newPos;
nsAutoLock lock(nsCacheService::ServiceLock()); // grab service lock
//nsAutoLock lock(nsCacheService::ServiceLock()); // grab service lock
if (!mBinding) return NS_ERROR_NOT_AVAILABLE;
if (PRUint32(offset) > mStreamEnd) return NS_ERROR_FAILURE;
@ -891,17 +835,11 @@ nsDiskCacheStreamIO::Tell(PRUint32 * result)
}
// SetEOF() will only be called by FileTransport.
// nsCacheEntryDescriptor::TransportWrapper::OpenOutputStream() will eventually update
// the cache entry, so we need only update the underlying data structure here.
//
// called only from nsDiskCacheOutputStream::SetEOF
// NOTE: called with service lock held
nsresult
nsDiskCacheStreamIO::SetEOF()
{
nsresult rv;
nsAutoLock lock(nsCacheService::ServiceLock()); // grab service lock
NS_ASSERTION(mStreamPos <= mStreamEnd, "bad stream");
if (!mBinding) return NS_ERROR_NOT_AVAILABLE;

17
netwerk/cache/src/nsDiskCacheStreams.h поставляемый
Просмотреть файл

@ -29,7 +29,6 @@
#include "nsCache.h"
#include "nsIStreamIO.h"
#include "nsIInputStream.h"
#include "nsIOutputStream.h"
@ -39,20 +38,17 @@ class nsDiskCacheInputStream;
class nsDiskCacheOutputStream;
class nsDiskCacheDevice;
class nsDiskCacheStreamIO : public nsIStreamIO {
// we're implementing nsIStreamIO to leverage the AsyncRead on the FileTransport thread
class nsDiskCacheStreamIO : public nsISupports {
public:
nsDiskCacheStreamIO(nsDiskCacheBinding * binding);
virtual ~nsDiskCacheStreamIO();
NS_DECL_ISUPPORTS
NS_DECL_NSISTREAMIO
// NS_DEFINE_STATIC_IID_ACCESSOR(NS_ISUPPORTS_IID)
void CloseInputStream(nsDiskCacheInputStream * inputStream);
nsresult CloseOutputStream(nsDiskCacheOutputStream * outputStream);
nsresult GetInputStream(PRUint32 offset, nsIInputStream ** inputStream);
nsresult GetOutputStream(PRUint32 offset, nsIOutputStream ** outputStream);
nsresult CloseOutputStream(nsDiskCacheOutputStream * outputStream);
nsresult Write( const char * buffer,
PRUint32 count,
@ -77,6 +73,7 @@ public:
private:
void Close();
nsresult OpenCacheFile(PRIntn flags, PRFileDesc ** fd);
nsresult ReadCacheBlocks();
nsresult FlushBufferToFile(PRBool clearBuffer); // XXX clearBuffer is always PR_TRUE

81
netwerk/cache/src/nsMemoryCacheDevice.cpp поставляемый
Просмотреть файл

@ -25,19 +25,11 @@
#include "nsMemoryCacheDevice.h"
#include "nsCacheService.h"
#include "nsICacheService.h"
#include "nsIComponentManager.h"
#include "nsIServiceManager.h"
#include "nsNetCID.h"
#include "nsIObserverService.h"
#include "nsIPref.h"
#include "nsIStorageStream.h"
#include "nsICacheVisitor.h"
#include "nsITransport.h"
#include "nsCRT.h"
#include <signal.h>
static NS_DEFINE_CID(kStorageTransportCID, NS_STORAGETRANSPORT_CID);
const char *gMemoryDeviceID = "memory";
@ -69,7 +61,7 @@ nsMemoryCacheDevice::Init()
nsresult rv = mMemCacheEntries.Init();
// set some default memory limits, in case prefs aren't available
mSoftLimit = mHardLimit * 0.9;
mSoftLimit = (mHardLimit * 9) / 10;
mInitialized = NS_SUCCEEDED(rv);
return rv;
@ -208,32 +200,65 @@ nsMemoryCacheDevice::DoomEntry(nsCacheEntry * entry)
nsresult
nsMemoryCacheDevice::GetTransportForEntry( nsCacheEntry * entry,
nsCacheAccessMode mode,
nsITransport ** transport )
nsMemoryCacheDevice::OpenInputStreamForEntry( nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIInputStream ** result)
{
NS_ENSURE_ARG_POINTER(entry);
NS_ENSURE_ARG_POINTER(transport);
NS_ENSURE_ARG_POINTER(result);
nsCOMPtr<nsISupports> data;
nsCOMPtr<nsIStorageStream> storage;
nsresult rv = entry->GetData(getter_AddRefs(data));
if (NS_FAILED(rv))
return rv;
if (data)
return CallQueryInterface(data, transport);
else {
// create a new transport for this entry
rv = nsComponentManager::CreateInstance(kStorageTransportCID,
nsnull,
NS_GET_IID(nsITransport),
(void **) transport);
if (NS_FAILED(rv)) return rv;
entry->SetData(*transport);
return NS_OK;
if (data) {
storage = do_QueryInterface(data, &rv);
if (NS_FAILED(rv))
return rv;
}
else {
rv = NS_NewStorageStream(4096, PRUint32(-1), getter_AddRefs(storage));
if (NS_FAILED(rv))
return rv;
entry->SetData(storage);
}
return storage->NewInputStream(offset, result);
}
nsresult
nsMemoryCacheDevice::OpenOutputStreamForEntry( nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIOutputStream ** result)
{
NS_ENSURE_ARG_POINTER(entry);
NS_ENSURE_ARG_POINTER(result);
nsCOMPtr<nsISupports> data;
nsCOMPtr<nsIStorageStream> storage;
nsresult rv = entry->GetData(getter_AddRefs(data));
if (NS_FAILED(rv))
return rv;
if (data) {
storage = do_QueryInterface(data, &rv);
if (NS_FAILED(rv))
return rv;
}
else {
rv = NS_NewStorageStream(4096, PRUint32(-1), getter_AddRefs(storage));
if (NS_FAILED(rv))
return rv;
entry->SetData(storage);
}
return storage->GetOutputStream(offset, result);
}
@ -251,7 +276,7 @@ nsMemoryCacheDevice::OnDataSizeChange( nsCacheEntry * entry, PRInt32 deltaSize)
if (entry->IsStreamData()) {
// we have the right to refuse or pre-evict
PRUint32 newSize = entry->DataSize() + deltaSize;
if (newSize > mSoftLimit) {
if ((PRInt32) newSize > mSoftLimit) {
nsresult rv = nsCacheService::DoomEntry(entry);
NS_ASSERTION(NS_SUCCEEDED(rv),"DoomEntry() failed.");
return NS_ERROR_ABORT;
@ -407,7 +432,7 @@ void
nsMemoryCacheDevice::SetCapacity(PRInt32 capacity)
{
PRInt32 hardLimit = capacity * 1024; // convert k into bytes
PRInt32 softLimit = hardLimit * 0.9;
PRInt32 softLimit = (hardLimit * 9) / 10;
AdjustMemoryLimits(softLimit, hardLimit);
}

12
netwerk/cache/src/nsMemoryCacheDevice.h поставляемый
Просмотреть файл

@ -50,9 +50,15 @@ public:
virtual void DoomEntry( nsCacheEntry * entry );
virtual nsresult DeactivateEntry( nsCacheEntry * entry );
virtual nsresult GetTransportForEntry( nsCacheEntry * entry,
nsCacheAccessMode mode,
nsITransport **transport );
virtual nsresult OpenInputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIInputStream ** result);
virtual nsresult OpenOutputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
PRUint32 offset,
nsIOutputStream ** result);
virtual nsresult GetFileForEntry( nsCacheEntry * entry,
nsIFile ** result );

252
netwerk/macbuild/netwerk.xml
Просмотреть файл

@ -1008,14 +1008,14 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransport.cpp</PATH>
<PATH>nsSocketTransport2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransportService.cpp</PATH>
<PATH>nsSocketTransportService2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
@ -1085,14 +1085,14 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransportService.cpp</PATH>
<PATH>nsStreamTransportService.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransport.cpp</PATH>
<PATH>nsInputStreamPump.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
@ -1386,28 +1386,7 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSimpleStreamProvider.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamListenerProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamProviderProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStorageTransport.cpp</PATH>
<PATH>nsAsyncStreamCopier.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
@ -1765,12 +1744,12 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransportService.cpp</PATH>
<PATH>nsStreamTransportService.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransport.cpp</PATH>
<PATH>nsInputStreamPump.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -1780,12 +1759,12 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransport.cpp</PATH>
<PATH>nsSocketTransport2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransportService.cpp</PATH>
<PATH>nsSocketTransportService2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -2050,22 +2029,7 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSimpleStreamProvider.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamListenerProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamProviderProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStorageTransport.cpp</PATH>
<PATH>nsAsyncStreamCopier.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -3260,14 +3224,14 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransport.cpp</PATH>
<PATH>nsSocketTransport2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransportService.cpp</PATH>
<PATH>nsSocketTransportService2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
@ -3337,14 +3301,14 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransportService.cpp</PATH>
<PATH>nsStreamTransportService.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransport.cpp</PATH>
<PATH>nsInputStreamPump.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
@ -3638,28 +3602,7 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSimpleStreamProvider.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamListenerProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamProviderProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStorageTransport.cpp</PATH>
<PATH>nsAsyncStreamCopier.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
@ -4017,12 +3960,12 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransportService.cpp</PATH>
<PATH>nsStreamTransportService.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransport.cpp</PATH>
<PATH>nsInputStreamPump.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -4032,12 +3975,12 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransport.cpp</PATH>
<PATH>nsSocketTransport2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransportService.cpp</PATH>
<PATH>nsSocketTransportService2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -4302,22 +4245,7 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSimpleStreamProvider.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamListenerProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamProviderProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStorageTransport.cpp</PATH>
<PATH>nsAsyncStreamCopier.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -5512,14 +5440,14 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransport.cpp</PATH>
<PATH>nsSocketTransport2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransportService.cpp</PATH>
<PATH>nsSocketTransportService2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
@ -5589,14 +5517,14 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransportService.cpp</PATH>
<PATH>nsStreamTransportService.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransport.cpp</PATH>
<PATH>nsInputStreamPump.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
@ -5876,28 +5804,7 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSimpleStreamProvider.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamListenerProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamProviderProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStorageTransport.cpp</PATH>
<PATH>nsAsyncStreamCopier.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
@ -6255,12 +6162,12 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransportService.cpp</PATH>
<PATH>nsStreamTransportService.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransport.cpp</PATH>
<PATH>nsInputStreamPump.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -6270,12 +6177,12 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransport.cpp</PATH>
<PATH>nsSocketTransport2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransportService.cpp</PATH>
<PATH>nsSocketTransportService2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -6530,22 +6437,7 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSimpleStreamProvider.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamListenerProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamProviderProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStorageTransport.cpp</PATH>
<PATH>nsAsyncStreamCopier.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -7740,14 +7632,14 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransport.cpp</PATH>
<PATH>nsSocketTransport2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransportService.cpp</PATH>
<PATH>nsSocketTransportService2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
@ -7817,14 +7709,14 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransportService.cpp</PATH>
<PATH>nsStreamTransportService.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransport.cpp</PATH>
<PATH>nsInputStreamPump.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
@ -8104,28 +7996,7 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSimpleStreamProvider.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamListenerProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamProviderProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStorageTransport.cpp</PATH>
<PATH>nsAsyncStreamCopier.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
@ -8483,12 +8354,12 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransportService.cpp</PATH>
<PATH>nsStreamTransportService.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransport.cpp</PATH>
<PATH>nsInputStreamPump.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -8498,12 +8369,12 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransport.cpp</PATH>
<PATH>nsSocketTransport2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransportService.cpp</PATH>
<PATH>nsSocketTransportService2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -8758,22 +8629,7 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSimpleStreamProvider.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamListenerProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamProviderProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStorageTransport.cpp</PATH>
<PATH>nsAsyncStreamCopier.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -9063,13 +8919,13 @@
<FILEREF>
<TARGETNAME>Necko.shlb</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransport.cpp</PATH>
<PATH>nsInputStreamPump.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>Necko.shlb</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsFileTransportService.cpp</PATH>
<PATH>nsStreamTransportService.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -9135,7 +8991,7 @@
<FILEREF>
<TARGETNAME>Necko.shlb</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSimpleStreamProvider.cpp</PATH>
<PATH>nsAsyncStreamCopier.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -9147,13 +9003,13 @@
<FILEREF>
<TARGETNAME>Necko.shlb</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransport.cpp</PATH>
<PATH>nsSocketTransport2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>Necko.shlb</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsSocketTransportService.cpp</PATH>
<PATH>nsSocketTransportService2.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -9162,18 +9018,6 @@
<PATH>nsStandardURL.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>Necko.shlb</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStorageTransport.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>Necko.shlb</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamListenerProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>Necko.shlb</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
@ -9192,12 +9036,6 @@
<PATH>nsUnicharStreamLoader.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>Necko.shlb</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsStreamProviderProxy.cpp</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>Necko.shlb</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>

202
netwerk/macbuild/netwerkIDL.xml
Просмотреть файл

@ -982,7 +982,7 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIFileTransportService.idl</PATH>
<PATH>nsIStreamTransportService.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
@ -1008,6 +1008,13 @@
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIBufferedStreams.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamLoader.idl</PATH>
@ -1059,7 +1066,7 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamIO.idl</PATH>
<PATH>nsIInputStreamPump.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
@ -1183,20 +1190,6 @@
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIAuthenticator.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIWebFilters.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIFTPChannel.idl</PATH>
@ -1283,14 +1276,7 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamProvider.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamProviderProxy.idl</PATH>
<PATH>nsIAsyncStreamCopier.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
@ -1318,7 +1304,7 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamIOChannel.idl</PATH>
<PATH>nsIInputStreamChannel.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
@ -1351,13 +1337,6 @@
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsISimpleStreamProvider.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIAuthPrompt.idl</PATH>
@ -1616,7 +1595,7 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIFileTransportService.idl</PATH>
<PATH>nsIStreamTransportService.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -1634,6 +1613,11 @@
<PATH>nsIFileStreams.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIBufferedStreams.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamLoader.idl</PATH>
@ -1671,7 +1655,7 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamIO.idl</PATH>
<PATH>nsIInputStreamPump.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -1759,16 +1743,6 @@
<PATH>nsIProxyAutoConfig.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIAuthenticator.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIWebFilters.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIFTPChannel.idl</PATH>
@ -1831,12 +1805,7 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamProvider.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamProviderProxy.idl</PATH>
<PATH>nsIAsyncStreamCopier.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -1856,7 +1825,7 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamIOChannel.idl</PATH>
<PATH>nsIInputStreamChannel.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -1879,11 +1848,6 @@
<PATH>nsISimpleStreamListener.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsISimpleStreamProvider.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIAuthPrompt.idl</PATH>
@ -2925,7 +2889,7 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIFileTransportService.idl</PATH>
<PATH>nsIStreamTransportService.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
@ -2951,6 +2915,13 @@
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIBufferedStreams.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamLoader.idl</PATH>
@ -3002,7 +2973,7 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamIO.idl</PATH>
<PATH>nsIInputStreamPump.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
@ -3119,20 +3090,6 @@
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIAuthenticator.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIWebFilters.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIFTPChannel.idl</PATH>
@ -3219,14 +3176,7 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamProvider.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamProviderProxy.idl</PATH>
<PATH>nsIAsyncStreamCopier.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
@ -3254,7 +3204,7 @@
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamIOChannel.idl</PATH>
<PATH>nsIInputStreamChannel.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
@ -3287,13 +3237,6 @@
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsISimpleStreamProvider.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Text</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIAuthPrompt.idl</PATH>
@ -3552,7 +3495,7 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIFileTransportService.idl</PATH>
<PATH>nsIStreamTransportService.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -3570,6 +3513,11 @@
<PATH>nsIFileStreams.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIBufferedStreams.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamLoader.idl</PATH>
@ -3607,7 +3555,7 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamIO.idl</PATH>
<PATH>nsIInputStreamPump.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -3690,16 +3638,6 @@
<PATH>nsIProxyAutoConfig.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIAuthenticator.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIWebFilters.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIFTPChannel.idl</PATH>
@ -3762,12 +3700,7 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamProvider.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamProviderProxy.idl</PATH>
<PATH>nsIAsyncStreamCopier.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -3787,7 +3720,7 @@
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamIOChannel.idl</PATH>
<PATH>nsIInputStreamChannel.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -3810,11 +3743,6 @@
<PATH>nsISimpleStreamListener.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsISimpleStreamProvider.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIAuthPrompt.idl</PATH>
@ -3980,12 +3908,6 @@
<PATH>nsIProxiedProtocolHandler.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIAuthenticator.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
@ -4028,12 +3950,6 @@
<PATH>nsIEventSinkGetter.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIFileChannel.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
@ -4043,7 +3959,13 @@
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIFileTransportService.idl</PATH>
<PATH>nsIBufferedStreams.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamTransportService.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -4157,7 +4079,7 @@
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamIOChannel.idl</PATH>
<PATH>nsIInputStreamChannel.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -4217,7 +4139,7 @@
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamIO.idl</PATH>
<PATH>nsIInputStreamPump.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -4241,13 +4163,7 @@
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamProvider.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIStreamProviderProxy.idl</PATH>
<PATH>nsIAsyncStreamCopier.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
@ -4286,12 +4202,6 @@
<PATH>nsIURLParser.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIWebFilters.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
@ -4310,12 +4220,6 @@
<PATH>nsISimpleStreamListener.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsISimpleStreamProvider.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
@ -4447,6 +4351,12 @@
<PATH>nsIFileProtocolHandler.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
<FILEREF>
<TARGETNAME>headers</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>nsIFileChannel.idl</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
</GROUP>
<GROUP><NAME>ftp</NAME>
<FILEREF>

14
netwerk/protocol/Makefile.in
Просмотреть файл

@ -26,8 +26,16 @@ VPATH = @srcdir@
include $(DEPTH)/config/autoconf.mk
DIRS = about data file ftp http keyword jar res \
gopher viewsource
DIRS = about \
data \
keyword \
res \
file \
jar \
http \
viewsource \
ftp \
gopher \
$(NULL)
include $(topsrcdir)/config/rules.mk

3
netwerk/protocol/about/src/nsAboutBlank.cpp
Просмотреть файл

@ -58,8 +58,7 @@ nsAboutBlank::NewChannel(nsIURI *aURI, nsIChannel **result)
rv = NS_NewInputStreamChannel(&channel, aURI, in,
NS_LITERAL_CSTRING("text/html"),
NS_LITERAL_CSTRING(""),
strlen(kBlankPage));
NS_LITERAL_CSTRING(""));
if (NS_FAILED(rv)) return rv;
*result = channel;

13
netwerk/protocol/about/src/nsAboutBloat.cpp
Просмотреть файл

@ -81,15 +81,12 @@ nsAboutBloat::NewChannel(nsIURI *aURI, nsIChannel **result)
}
nsCOMPtr<nsIInputStream> inStr;
PRUint32 size;
if (clear) {
nsTraceRefcnt::ResetStatistics();
const char* msg = "Bloat statistics cleared.";
rv = NS_NewCStringInputStream(getter_AddRefs(inStr), nsDependentCString(msg));
if (NS_FAILED(rv)) return rv;
size = strlen(msg);
}
else if (leaks) {
// dump the current set of leaks.
@ -98,8 +95,6 @@ nsAboutBloat::NewChannel(nsIURI *aURI, nsIChannel **result)
const char* msg = "Memory leaks dumped.";
rv = NS_NewCStringInputStream(getter_AddRefs(inStr), nsDependentCString(msg));
if (NS_FAILED(rv)) return rv;
size = strlen(msg);
}
else {
nsCOMPtr<nsIFile> file;
@ -146,11 +141,6 @@ nsAboutBloat::NewChannel(nsIURI *aURI, nsIChannel **result)
::fclose(out);
if (NS_FAILED(rv)) return rv;
PRInt64 bigSize;
rv = file->GetFileSize(&bigSize);
if (NS_FAILED(rv)) return rv;
LL_L2UI(size, bigSize);
rv = NS_NewLocalFileInputStream(getter_AddRefs(inStr), file);
if (NS_FAILED(rv)) return rv;
}
@ -158,8 +148,7 @@ nsAboutBloat::NewChannel(nsIURI *aURI, nsIChannel **result)
nsIChannel* channel;
rv = NS_NewInputStreamChannel(&channel, aURI, inStr,
NS_LITERAL_CSTRING("text/plain"),
NS_LITERAL_CSTRING(""),
size);
NS_LITERAL_CSTRING(""));
if (NS_FAILED(rv)) return rv;
*result = channel;

7
netwerk/protocol/about/src/nsAboutCache.cpp
Просмотреть файл

@ -139,10 +139,6 @@ nsAboutCache::NewChannel(nsIURI *aURI, nsIChannel **result)
outputStream->Write(mBuffer.get(), mBuffer.Length(), &bytesWritten);
nsCOMPtr<nsIInputStream> inStr;
PRUint32 size;
rv = storageStream->GetLength(&size);
if (NS_FAILED(rv)) return rv;
rv = storageStream->NewInputStream(0, getter_AddRefs(inStr));
if (NS_FAILED(rv)) return rv;
@ -150,8 +146,7 @@ nsAboutCache::NewChannel(nsIURI *aURI, nsIChannel **result)
nsIChannel* channel;
rv = NS_NewInputStreamChannel(&channel, aURI, inStr,
NS_LITERAL_CSTRING("text/html"),
NS_LITERAL_CSTRING(""),
size);
NS_LITERAL_CSTRING(""));
if (NS_FAILED(rv)) return rv;
*result = channel;

27
netwerk/protocol/about/src/nsAboutCacheEntry.cpp
Просмотреть файл

@ -66,11 +66,13 @@ nsAboutCacheEntry::NewChannel(nsIURI *aURI, nsIChannel **result)
{
nsresult rv;
nsCOMPtr<nsIStreamIOChannel> chan;
rv = NS_NewStreamIOChannel(getter_AddRefs(chan), aURI, nsnull);
nsCOMPtr<nsIChannel> chan;
rv = NS_NewInputStreamChannel(getter_AddRefs(chan), aURI, nsnull,
NS_LITERAL_CSTRING("application/xhtml+xml"));
if (NS_FAILED(rv)) return rv;
mStreamChannel = do_QueryInterface(chan);
mStreamChannel = do_QueryInterface(chan, &rv);
if (NS_FAILED(rv)) return rv;
return CallQueryInterface((nsIAboutModule *) this, result);
}
@ -125,24 +127,7 @@ nsAboutCacheEntry::OnCacheEntryAvailable(nsICacheEntryDescriptor *descriptor,
rv = storageStream->NewInputStream(0, getter_AddRefs(inStr));
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIURI> uri;
rv = mStreamChannel->GetURI(getter_AddRefs(uri));
if (NS_FAILED(rv)) return rv;
nsCAutoString spec;
rv = uri->GetSpec(spec);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIInputStreamIO> io;
rv = NS_NewInputStreamIO(getter_AddRefs(io), spec, inStr,
NS_LITERAL_CSTRING("application/xhtml+xml"),
NS_LITERAL_CSTRING(""),
size);
nsCOMPtr<nsIStreamIOChannel> chan = do_QueryInterface(mStreamChannel, &rv);
if (NS_FAILED(rv)) return rv;
rv = chan->Init(uri, io);
rv = mStreamChannel->SetContentStream(inStr);
if (NS_FAILED(rv)) return rv;
return mStreamChannel->AsyncOpen(mListener, mListenerContext);

5
netwerk/protocol/about/src/nsAboutCacheEntry.h
Просмотреть файл

@ -46,6 +46,8 @@
#include "nsICacheEntryDescriptor.h"
#include "nsIStreamListener.h"
#include "nsIOutputStream.h"
#include "nsIInputStreamChannel.h"
#include "nsIURI.h"
#include "nsCOMPtr.h"
#include "nsString.h"
@ -76,7 +78,8 @@ private:
nsresult ParseURI(nsCString &, PRBool &, nsCString &);
private:
nsCOMPtr<nsIChannel> mStreamChannel;
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsIInputStreamChannel> mStreamChannel;
nsCOMPtr<nsIStreamListener> mListener;
nsCOMPtr<nsISupports> mListenerContext;
nsCOMPtr<nsICacheSession> mCacheSession;

3
netwerk/protocol/data/src/nsDataHandler.h
Просмотреть файл

@ -39,9 +39,6 @@
#define nsDataHandler_h___
#include "nsIProtocolHandler.h"
// {B6ED3030-6183-11d3-A178-0050041CAF44}
#define NS_DATAHANDLER_CID \
{ 0xb6ed3030, 0x6183, 0x11d3, { 0xa1, 0x78, 0x00, 0x50, 0x04, 0x1c, 0xaf, 0x44 } }
class nsDataHandler : public nsIProtocolHandler
{

1
netwerk/protocol/file/public/MANIFEST_IDL
Просмотреть файл

@ -1 +1,2 @@
nsIFileProtocolHandler.idl
nsIFileChannel.idl

Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше