Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-04-02 20:42:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Moved read/write methods from TransportService to Transport.

Browse Source
This commit is contained in:
warren%netscape.com 1999-04-14 08:10:50 +00:00
parent a416e50fae
commit 65c8d98792
10 changed files with 195 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -26,6 +26,7 @@ EXPORTS = \
nsINetService.h \
nsIProtocolConnection.h \
nsIProtocolHandler.h \
nsISocketTransportService.h \
nsIStreamListener.h \
nsIStreamObserver.h \
nsITransport.h \

33
netwerk/base/public/nsIFileTransportService.h
View File

@ -20,13 +20,8 @@
#define nsIFileTransportService_h___
#include "nsISupports.h"
#include "plevent.h"
class nsIStreamObserver;
class nsIStreamListener;
class nsITransport;
class nsIInputStream;
class nsIOutputStream;
#define NS_IFILETRANSPORTSERVICE_IID \
{ /* 2355dca0-ea35-11d2-931b-00104ba0fd40 */ \
@ -49,32 +44,8 @@ class nsIFileTransportService : public nsISupports
public:
NS_DEFINE_STATIC_IID_ACCESSOR(NS_IFILETRANSPORTSERVICE_IID);
// Async routines: By calling these the calling thread agrees
// to eventually return to an event loop that will be notified
// with incoming data, calling the listener.
NS_IMETHOD AsyncRead(const char* path,
nsISupports* context,
PLEventQueue* appEventQueue,
nsIStreamListener* listener,
nsITransport* *result) = 0;
NS_IMETHOD AsyncWrite(nsIInputStream* fromStream,
const char* path,
nsISupports* context,
PLEventQueue* appEventQueue,
nsIStreamObserver* observer,
nsITransport* *result) = 0;
// Synchronous routines
NS_IMETHOD OpenInputStream(const char* path,
nsISupports* context,
nsIInputStream* *result) = 0;
NS_IMETHOD OpenOutputStream(const char* path,
nsISupports* context,
nsIOutputStream* *result) = 0;
NS_IMETHOD CreateTransport(const char* path,
nsITransport* *result) = 0;
NS_IMETHOD ProcessPendingRequests(void) = 0;
};

7
netwerk/base/public/nsIProtocolConnection.h
View File

@ -38,6 +38,8 @@ class nsIProtocolConnection : public nsICancelable
public:
NS_DEFINE_STATIC_IID_ACCESSOR(NS_IPROTOCOLCONNECTION_IID);
NS_IMETHOD Open(void) = 0;
// can be called after Open
// freed by caller with delete[]
NS_IMETHOD GetContentType(char* *contentType) = 0;
@ -48,11 +50,6 @@ public:
// blocking:
NS_IMETHOD GetOutputStream(nsIOutputStream* *result) = 0;
// bletch...
NS_IMETHOD AsyncWrite(nsIInputStream* data, PRUint32 count,
nsresult (*callback)(void* closure, PRUint32 count),
void* closure) = 0;
};
#define NS_ERROR_NOT_CONNECTED NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 3)

56
netwerk/base/public/nsISocketTransportService.h Normal file
View File

@ -0,0 +1,56 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
#ifndef nsISocketTransportService_h___
#define nsISocketTransportService_h___
#include "nsISupports.h"
class nsITransport;
// XXX regenerate:
#define NS_ISOCKETTRANSPORTSERVICE_IID \
{ /* 2355dca0-ea35-11d2-931b-00104ba0fd40 */ \
0x2355dca0, \
0xea35, \
0x11d2, \
{0x93, 0x1b, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40} \
}
// XXX regenerate:
#define NS_SOCKETTRANSPORTSERVICE_CID \
{ /* 2bb2b250-ea35-11d2-931b-00104ba0fd40 */ \
0x2bb2b250, \
0xea35, \
0x11d2, \
{0x93, 0x1b, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40} \
}
class nsISocketTransportService : public nsISupports
{
public:
NS_DEFINE_STATIC_IID_ACCESSOR(NS_ISOCKETTRANSPORTSERVICE_IID);
NS_IMETHOD CreateTransport(const char* host, PRInt32 port,
nsITransport* *result) = 0;
};
////////////////////////////////////////////////////////////////////////////////
#endif /* nsISocketTransportService_h___ */

22
netwerk/base/public/nsITransport.h
View File

@ -20,9 +20,12 @@
#define nsITransport_h___
#include "nsICancelable.h"
#include "plevent.h"
class nsIStreamListener;
class nsIStreamObserver;
class nsIInputStream;
class nsIOutputStream;
#define NS_ITRANSPORT_IID \
{ /* 7aa38100-ea35-11d2-931b-00104ba0fd40 */ \
@ -37,6 +40,25 @@ class nsITransport : public nsICancelable
public:
NS_DEFINE_STATIC_IID_ACCESSOR(NS_ITRANSPORT_IID);
// Async routines: By calling these the calling thread agrees
// to eventually return to an event loop that will be notified
// with incoming data, calling the listener.
NS_IMETHOD AsyncRead(nsISupports* context,
PLEventQueue* appEventQueue,
nsIStreamListener* listener) = 0;
NS_IMETHOD AsyncWrite(nsIInputStream* fromStream,
nsISupports* context,
PLEventQueue* appEventQueue,
nsIStreamObserver* observer) = 0;
// Synchronous routines
NS_IMETHOD OpenInputStream(nsIInputStream* *result) = 0;
NS_IMETHOD OpenOutputStream(nsIOutputStream* *result) = 0;
};
#endif /* nsITransport_h___ */

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

@ -32,7 +32,8 @@ static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
nsFileTransport::nsFileTransport()
: mPath(nsnull), mContext(nsnull), mListener(nsnull), mState(STARTING),
mFileStream(nsnull), mBufferStream(nsnull), mStatus(NS_OK)
mFileStream(nsnull), mBufferStream(nsnull), mStatus(NS_OK),
mService(nsnull)
{
NS_INIT_REFCNT();
}
@ -49,22 +50,30 @@ nsFileTransport::~nsFileTransport()
nsresult
nsFileTransport::Init(const char* path,
nsISupports* context,
nsIStreamListener* listener,
nsFileTransportService* service)
{
mPath = nsCRT::strdup(path);
if (mPath == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
mService = service;
NS_ADDREF(mService);
return NS_OK;
}
nsresult
nsFileTransport::Init(nsISupports* context,
nsIStreamListener* listener,
State state)
{
mContext = context;
NS_IF_ADDREF(mContext);
mListener = listener;
NS_ADDREF(mListener);
mService = service;
NS_ADDREF(mService);
mState = state;
return NS_OK;
}
@ -157,6 +166,71 @@ nsFileTransport::Resume(void)
return rv;
}
////////////////////////////////////////////////////////////////////////////////
// nsITransport methods:
NS_IMETHODIMP
nsFileTransport::AsyncRead(nsISupports* context,
PLEventQueue* appEventQueue,
nsIStreamListener* listener)
{
nsresult rv;
nsIStreamListener* asyncListener;
rv = NS_NewAsyncStreamListener(&asyncListener, appEventQueue, listener);
if (NS_FAILED(rv)) return rv;
rv = Init(context, asyncListener, STARTING);
NS_RELEASE(asyncListener);
rv = mService->DispatchRequest(this);
if (NS_FAILED(rv)) return rv;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::AsyncWrite(nsIInputStream* fromStream,
nsISupports* context,
PLEventQueue* appEventQueue,
nsIStreamObserver* observer)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsFileTransport::OpenInputStream(nsIInputStream* *result)
{
nsresult rv;
nsIStreamListener* syncListener;
nsIInputStream* inStr;
rv = NS_NewSyncStreamListener(&syncListener, &inStr);
if (NS_FAILED(rv)) return rv;
rv = Init(nsnull, syncListener, STARTING);
NS_RELEASE(syncListener);
if (NS_FAILED(rv)) {
NS_RELEASE(inStr);
return rv;
}
rv = mService->DispatchRequest(this);
if (NS_FAILED(rv)) {
NS_RELEASE(inStr);
return rv;
}
*result = inStr;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransport::OpenOutputStream(nsIOutputStream* *result)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
////////////////////////////////////////////////////////////////////////////////
void
@ -193,7 +267,7 @@ nsFileTransport::Continue(void)
if (NS_FAILED(mStatus)) goto error;
// and feed the buffer to the application via the byte buffer stream:
mStatus = mListener->OnDataAvailable(mContext, mBufferStream, amt); // XXX maybe amt should be bufStr->GetLength()
mStatus = mListener->OnDataAvailable(mContext, mBufferStream, amt); // XXX maybe amt should be mBufferStream->GetLength()
if (NS_FAILED(mStatus)) goto error;
// stay in the RUNNING state

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

@ -39,6 +39,15 @@ public:
NS_IMETHOD Resume(void);
// nsITransport methods:
NS_IMETHOD AsyncRead(nsISupports* context,
PLEventQueue* appEventQueue,
nsIStreamListener* listener);
NS_IMETHOD AsyncWrite(nsIInputStream* fromStream,
nsISupports* context,
PLEventQueue* appEventQueue,
nsIStreamObserver* observer);
NS_IMETHOD OpenInputStream(nsIInputStream* *result);
NS_IMETHOD OpenOutputStream(nsIOutputStream* *result);
// nsIRunnable methods:
NS_IMETHOD Run(void);
@ -47,12 +56,6 @@ public:
nsFileTransport();
virtual ~nsFileTransport();
nsresult Init(const char* path,
nsISupports* context,
nsIStreamListener* listener,
nsFileTransportService* service);
void Continue(void);
enum State {
STARTING,
RUNNING,
@ -61,6 +64,13 @@ public:
ENDED
};
nsresult Init(const char* path,
nsFileTransportService* service);
nsresult Init(nsISupports* context,
nsIStreamListener* listener,
State state);
void Continue(void);
protected:
char* mPath;
nsISupports* mContext;

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

@ -20,7 +20,6 @@
#include "nsFileTransport.h"
#include "nsIThread.h"
#include "nsIFileStream.h"
#include "prcmon.h"
#include "prmem.h"
#include "nsIStreamListener.h"
@ -51,100 +50,38 @@ nsFileTransportService::~nsFileTransportService()
NS_IMPL_ISUPPORTS(nsFileTransportService, nsIFileTransportService::GetIID());
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsFileTransportService::AsyncRead(const char* path,
nsISupports* context,
PLEventQueue* appEventQueue,
nsIStreamListener* listener,
nsITransport* *result)
nsFileTransportService::CreateTransport(const char* path,
nsITransport* *result)
{
nsresult rv;
nsFileTransport* trans = new nsFileTransport();
if (trans == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
nsIStreamListener* asyncListener;
rv = NS_NewAsyncStreamListener(&asyncListener, appEventQueue, listener);
if (NS_FAILED(rv)) return rv;
rv = trans->Init(path, context, asyncListener, this);
NS_RELEASE(asyncListener);
rv = trans->Init(path, this);
if (NS_FAILED(rv)) {
delete trans;
return rv;
}
NS_ADDREF(trans);
rv = mPool->DispatchRequest(NS_STATIC_CAST(nsIRunnable*, trans));
if (NS_FAILED(rv)) {
NS_RELEASE(trans);
return rv;
}
*result = trans;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransportService::AsyncWrite(nsIInputStream* fromStream,
const char* path,
nsISupports* context,
PLEventQueue* appEventQueue,
nsIStreamObserver* observer,
nsITransport* *result)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsFileTransportService::OpenInputStream(const char* path,
nsISupports* context,
nsIInputStream* *result)
{
nsresult rv;
nsFileTransport* trans = new nsFileTransport();
if (trans == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
nsIStreamListener* syncListener;
nsIInputStream* inStr;
rv = NS_NewSyncStreamListener(&syncListener, &inStr);
if (NS_FAILED(rv)) return rv;
rv = trans->Init(path, context, syncListener, this);
NS_RELEASE(syncListener);
if (NS_FAILED(rv)) {
NS_RELEASE(inStr);
delete trans;
return rv;
}
NS_ADDREF(trans);
rv = mPool->DispatchRequest(NS_STATIC_CAST(nsIRunnable*, trans));
NS_RELEASE(trans);
if (NS_FAILED(rv)) {
NS_RELEASE(inStr);
return rv;
}
*result = inStr;
return NS_OK;
}
NS_IMETHODIMP
nsFileTransportService::OpenOutputStream(const char* path,
nsISupports* context,
nsIOutputStream* *result)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsFileTransportService::ProcessPendingRequests(void)
{
return mPool->ProcessPendingRequests();
}
nsresult
nsFileTransportService::DispatchRequest(nsIRunnable* runnable)
{
return mPool->DispatchRequest(runnable);
}
////////////////////////////////////////////////////////////////////////////////
nsresult

20
netwerk/base/src/nsFileTransportService.h
View File

@ -37,23 +37,8 @@ public:
NS_DECL_ISUPPORTS
// nsIFileTransportService methods:
NS_IMETHOD AsyncRead(const char* path,
nsISupports* context,
PLEventQueue* appEventQueue,
nsIStreamListener* listener,
nsITransport* *result);
NS_IMETHOD AsyncWrite(nsIInputStream* fromStream,
const char* path,
nsISupports* context,
PLEventQueue* appEventQueue,
nsIStreamObserver* observer,
nsITransport* *result);
NS_IMETHOD OpenInputStream(const char* path,
nsISupports* context,
nsIInputStream* *result);
NS_IMETHOD OpenOutputStream(const char* path,
nsISupports* context,
nsIOutputStream* *result);
NS_IMETHOD CreateTransport(const char* path,
nsITransport* *result);
NS_IMETHOD ProcessPendingRequests(void);
// nsFileTransportService methods:
@ -61,6 +46,7 @@ public:
virtual ~nsFileTransportService();
nsresult Init();
nsresult DispatchRequest(nsIRunnable* runnable);
nsresult Suspend(nsFileTransport* request);
nsresult Resume(nsFileTransport* request);

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

@ -108,7 +108,7 @@ nsSyncStreamListener::OnDataAvailable(nsISupports* context,
nsresult rv;
PRUint32 amt;
PRInt32 count = (PRInt32)aLength;
while (count > 0) {
while (count > 0) { // this should only go around once since the output stream is blocking
rv = mOutputStream->Write(aIStream, &amt);
if (NS_FAILED(rv)) return rv;
count -= amt;