Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-12-25 17:43:44 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
050ad45bf2
gecko-dev/network/module/nsNetThread.cpp

928 lines
24 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* The Original Code is Mozilla Communicator client code.
*
* The Initial Developer of the Original Code is Netscape Communications
* Corporation. Portions created by Netscape are Copyright (C) 1998
* Netscape Communications Corporation. All Rights Reserved.
*/
#include "nscore.h"
#include "nsIComponentManager.h"
#include "nspr.h"
#include "plevent.h"
#include "plstr.h"
#include "nsNetThread.h"
#include "nsIEventQueueService.h"
#include "nsIStreamListener.h"
#include "nsIInputStream.h"
#include "nsIURL.h"
#include "nsString.h"
#include "nsIRelatedLinks.h"
extern "C" {
#include "sockstub.h"
#include "mkutils.h"
#include "mkgeturl.h"
#include "mktrace.h"
#include "mkstream.h"
#include "cvchunk.h"
#include "cvunzip.h"
#include "cvplugin.h"
#include "fileurl.h"
#include "httpurl.h"
#include "ftpurl.h"
#include "abouturl.h"
#include "gophurl.h"
#include "fileurl.h"
#include "remoturl.h"
#include "netcache.h"
#include "cvactive.h"
#include "nsCRT.h"
PUBLIC NET_StreamClass *
NET_NGLayoutConverter(FO_Present_Types format_out,
void *converter_obj,
URL_Struct *URL_s,
MWContext *context);
void net_AddrefContext(MWContext *context);
void net_ReleaseContext(MWContext *context);
} /* end of extern "C" */
#if defined(XP_PC)
void net_InitAsyncDNS();
#endif /* XP_PC */
PRThread* gNetlibThread = nsnull;
/*
* Initialize our protocols
*/
extern "C" void NET_ClientProtocolInitialize()
{
NET_InitSockStubProtocol();
NET_InitFileProtocol();
NET_InitHTTPProtocol();
#ifdef NU_CACHE
NET_InitNuCacheProtocol();
#else
NET_InitMemCacProtocol();
#endif
NET_InitFTPProtocol();
NET_InitAboutProtocol();
NET_InitGopherProtocol();
NET_InitRemoteProtocol();
}
nsresult NS_InitNetlib(void)
{
/* Initialize netlib with 32 sockets... */
NET_InitNetLib(0, 32);
/* Initialize the file extension -> content-type mappings */
NET_InitFileFormatTypes(nsnull, nsnull);
NET_FinishInitNetLib();
NET_RegisterContentTypeConverter("*", FO_CACHE_AND_NGLAYOUT, NULL,
NET_CacheConverter);
NET_RegisterContentTypeConverter("*", FO_NGLAYOUT, NULL,
NET_NGLayoutConverter);
NET_RegisterContentTypeConverter(APPLICATION_HTTP_INDEX, FO_NGLAYOUT,
NULL, NET_HTTPIndexFormatToHTMLConverter);
NET_RegisterContentTypeConverter("text/*", FO_NGLAYOUT, NULL,
NET_PluginStream);
NET_RegisterContentTypeConverter("image/*", FO_NGLAYOUT, NULL,
NET_PluginStream);
NET_RegisterContentTypeConverter("application/*", FO_NGLAYOUT, NULL,
NET_PluginStream);
NET_RegisterContentTypeConverter(MESSAGE_RFC822, FO_NGLAYOUT, NULL,
NET_PluginStream);
NET_RegisterEncodingConverter(ENCODING_GZIP,
(void *) ENCODING_GZIP,
NET_UnZipConverter);
NET_RegisterEncodingConverter(ENCODING_GZIP2,
(void *) ENCODING_GZIP2,
NET_UnZipConverter);
NET_RegisterAllEncodingConverters("*", FO_NGLAYOUT);
NET_RegisterUniversalEncodingConverter("chunked",
NULL,
NET_ChunkedDecoderStream);
NET_RegisterContentTypeConverter("multipart/x-mixed-replace", FO_NGLAYOUT,
(void *) CVACTIVE_SIGNAL_AT_END_OF_MULTIPART,
CV_MakeMultipleDocumentStream);
NET_RegisterContentTypeConverter("multipart/mixed", FO_NGLAYOUT,
(void *) CVACTIVE_SIGNAL_AT_END_OF_MULTIPART,
CV_MakeMultipleDocumentStream);
#if defined(XP_PC)
net_InitAsyncDNS();
#endif /* XP_PC */
return NS_OK;
}
nsNetlibThread::nsNetlibThread()
{
mIsNetlibThreadRunning = PR_FALSE;
mNetlibEventQueue = nsnull;
}
nsNetlibThread::~nsNetlibThread()
{
Stop();
}
nsresult nsNetlibThread::Start(void)
{
nsresult rv = NS_OK;
#if defined(NETLIB_THREAD)
#if defined(NSPR20) && defined(DEBUG)
if (NETLIB==NULL) {
NETLIB = PR_NewLogModule("NETLIB");
}
#endif
/*
* Create the netlib thread and wait for it to initialize Netlib...
*/
PR_CEnterMonitor(this);
mThread = PR_CreateThread(PR_USER_THREAD,
nsNetlibThread::NetlibThreadMain,
this,
PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD,
4096);
/*
* The netlib thread will call PR_Notify on the monitor when Netlib has
* been initialized...
*/
PR_CWait(this, PR_INTERVAL_NO_TIMEOUT);
PR_CExitMonitor(this);
NET_ReadCookies("");
#else
/*
* Initialize Netlib...
*/
NS_InitNetlib();
#endif /* !NETLIB_THREAD */
return rv;
}
nsresult nsNetlibThread::Stop(void)
{
#if defined(NETLIB_THREAD)
PR_CEnterMonitor(this);
if (PR_TRUE == mIsNetlibThreadRunning) {
mIsNetlibThreadRunning = PR_FALSE;
PR_CWait(this, PR_INTERVAL_NO_TIMEOUT);
}
PR_CExitMonitor(this);
#else
NET_ShutdownNetLib();
#endif /* !NETLIB_THREAD */
return NS_OK;
}
void nsNetlibThread::NetlibThreadMain(void *aParam)
{
nsNetlibThread* me = (nsNetlibThread*)aParam;
PR_CEnterMonitor(me);
me->mNetlibEventQueue = PL_CreateEventQueue("Netlib Event Queue", PR_GetCurrentThread());
if (nsnull == me->mNetlibEventQueue) {
PR_CNotify(me);
PR_CExitMonitor(me);
/* XXX: return error status... */
return;
}
/*
* Initialize netlib on the netlib thread...
*/
NS_InitNetlib();
gNetlibThread = PR_GetCurrentThread();
me->mIsNetlibThreadRunning = PR_TRUE;
/*
* Notify the caller thread that Netlib is now initialized...
*/
PR_CNotify(me);
PR_CExitMonitor(me);
/*
* Call the platform specific main loop...
*/
me->NetlibMainLoop();
/*
* Netlib is being shutdown... Clean up and exit.
*/
PR_CEnterMonitor(me);
me->mIsNetlibThreadRunning = PR_FALSE;
/* Notify the main thread that the Netlib thread is no longer running...*/
PR_CNotify(me);
PR_CExitMonitor(me);
PL_DestroyEventQueue(me->mNetlibEventQueue);
me->mNetlibEventQueue = nsnull;
NET_ShutdownNetLib();
}
/*
* Platform specific main loop...
*/
#if defined(XP_PC)
void CALLBACK NetlibTimerProc(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime)
{
(void) NET_PollSockets();
}
void nsNetlibThread::NetlibMainLoop(void)
{
UINT timerId;
/*
* Create a timer to periodically call NET_PollSockets(...)
*/
#if !defined(NO_NETWORK_POLLING)
timerId = SetTimer(NULL, 0, 10, (TIMERPROC)NetlibTimerProc);
#endif /* NO_NETWORK_POLLING */
while (PR_TRUE == mIsNetlibThreadRunning) {
MSG msg;
BOOL bIsMsg;
/*
* Block for network activity...
*
* If NET_CallingNetlibAllTheTime(...) is set, then do not block
* because a non-socket based protocol is being serviced (ie. file)
*/
if (NET_IsCallNetlibAllTheTimeSet(NULL, NULL)) {
NET_ProcessNet(NULL, NET_EVERYTIME_TYPE);
bIsMsg = PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
} else {
bIsMsg = GetMessage(&msg, NULL, 0, 0);
}
if (FALSE != bIsMsg) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
#if !defined(NO_NETWORK_POLLING)
KillTimer(NULL, timerId);
#endif /* NO_NETWORK_POLLING */
}
#else
void nsNetlibThread::NetlibMainLoop()
{
while (mIsNetlibThreadRunning) {
if (NET_IsCallNetlibAllTheTimeSet(NULL, NULL))
NET_ProcessNet(NULL, NET_EVERYTIME_TYPE);
else
NET_PollSockets();
}
}
#endif /* ! XP_PC */
/*
* Proxy implementation for the nsIStreamListener interface...
*/
class nsStreamListenerProxy : public nsIStreamListener
{
public:
nsStreamListenerProxy(nsIStreamListener* aListener, nsIEventQueue* aEventQ);
NS_DECL_ISUPPORTS
NS_IMETHOD OnStartRequest(nsIURI* aURL, const char *aContentType);
NS_IMETHOD OnProgress(nsIURI* aURL, PRUint32 aProgress, PRUint32 aProgressMax);
NS_IMETHOD OnStatus(nsIURI* aURL, const PRUnichar* aMsg);
NS_IMETHOD OnStopRequest(nsIURI* aURL, nsresult aStatus, const PRUnichar* aMsg);
NS_IMETHOD GetBindInfo(nsIURI* aURL, nsStreamBindingInfo* info);
NS_IMETHOD OnDataAvailable(nsIURI* aURL, nsIInputStream *aIStream,
PRUint32 aLength);
void SetStatus(nsresult aStatus);
nsresult GetStatus();
nsIStreamListener* mRealListener;
protected:
virtual ~nsStreamListenerProxy();
private:
nsresult mStatus;
nsIEventQueue* mEventQ;
};
/*-------------------- Base Proxy Class ------------------------------------*/
struct ProxyEvent : public PLEvent
{
virtual ~ProxyEvent();
virtual void InitEvent();
NS_IMETHOD HandleEvent() = 0;
void Fire(nsIEventQueue* aEventQ);
static void PR_CALLBACK HandlePLEvent(PLEvent* aEvent);
static void PR_CALLBACK DestroyPLEvent(PLEvent* aEvent);
};
ProxyEvent::~ProxyEvent()
{
}
void ProxyEvent::InitEvent()
{
PL_InitEvent(this, nsnull,
(PLHandleEventProc) ProxyEvent::HandlePLEvent,
(PLDestroyEventProc) ProxyEvent::DestroyPLEvent);
}
void PR_CALLBACK ProxyEvent::HandlePLEvent(PLEvent* aEvent)
{
/*
* XXX: This is a dangerous cast since it must adjust the pointer
* to compensate for the vtable...
*/
ProxyEvent *ev = (ProxyEvent*)aEvent;
ev->HandleEvent();
}
void PR_CALLBACK ProxyEvent::DestroyPLEvent(PLEvent* aEvent)
{
/*
* XXX: This is a dangerous cast since it must adjust the pointer
* to compensate for the vtable...
*/
ProxyEvent *ev = (ProxyEvent*)aEvent;
delete ev;
}
void ProxyEvent::Fire(nsIEventQueue* aEventQ)
{
InitEvent();
NS_PRECONDITION(nsnull != aEventQ, "nsIEventQueue for thread is null");
aEventQ->PostEvent(this);
}
/*--------- Base Class for the nsIStreamListenerProxy Class ----------------*/
struct StreamListenerProxyEvent : public ProxyEvent
{
StreamListenerProxyEvent(nsStreamListenerProxy* aProxy, nsIURI* aURL);
virtual ~StreamListenerProxyEvent();
virtual void InitEvent();
static void PR_CALLBACK HandlePLEvent(PLEvent* aEvent);
nsStreamListenerProxy* mProxy;
nsIURI* mURL;
};
StreamListenerProxyEvent::StreamListenerProxyEvent(nsStreamListenerProxy* aProxy, nsIURI* aURL)
{
mProxy = aProxy;
mURL = aURL;
NS_IF_ADDREF(mProxy);
NS_IF_ADDREF(mURL);
}
StreamListenerProxyEvent::~StreamListenerProxyEvent()
{
NS_IF_RELEASE(mProxy);
NS_IF_RELEASE(mURL);
}
void StreamListenerProxyEvent::InitEvent()
{
PL_InitEvent(this, nsnull,
(PLHandleEventProc) StreamListenerProxyEvent::HandlePLEvent,
(PLDestroyEventProc) ProxyEvent::DestroyPLEvent);
}
void PR_CALLBACK StreamListenerProxyEvent::HandlePLEvent(PLEvent* aEvent)
{
/*
* XXX: This is a dangerous cast since it must adjust the pointer
* to compensate for the vtable...
*/
nsresult rv;
StreamListenerProxyEvent *ev = (StreamListenerProxyEvent*)aEvent;
rv = ev->HandleEvent();
if (NS_FAILED(rv)) {
ev->mProxy->SetStatus(rv);
}
}
/*-------------- OnStartRequest Proxy --------------------------------------*/
struct OnStartRequestProxyEvent : public StreamListenerProxyEvent
{
OnStartRequestProxyEvent(nsStreamListenerProxy* aProxy, nsIURI* aURL,
const char *aContentType);
virtual ~OnStartRequestProxyEvent();
NS_IMETHOD HandleEvent();
char *mContentType;
};
OnStartRequestProxyEvent::OnStartRequestProxyEvent(nsStreamListenerProxy* aProxy,
nsIURI* aURL,
const char *aContentType)
: StreamListenerProxyEvent(aProxy, aURL)
{
mContentType = PL_strdup(aContentType);
}
OnStartRequestProxyEvent::~OnStartRequestProxyEvent()
{
PR_Free(mContentType);
}
NS_IMETHODIMP
OnStartRequestProxyEvent::HandleEvent()
{
return mProxy->mRealListener->OnStartRequest(mURL, mContentType);
}
/*-------------- OnProgress Proxy ------------------------------------------*/
struct OnProgressProxyEvent : public StreamListenerProxyEvent
{
OnProgressProxyEvent(nsStreamListenerProxy* aProxy, nsIURI* aURL,
PRUint32 aProgress, PRUint32 aProgressMax);
NS_IMETHOD HandleEvent();
PRUint32 mProgress;
PRUint32 mProgressMax;
};
OnProgressProxyEvent::OnProgressProxyEvent(nsStreamListenerProxy* aProxy,
nsIURI* aURL,
PRUint32 aProgress,
PRUint32 aProgressMax)
: StreamListenerProxyEvent(aProxy, aURL)
{
mProgress = aProgress;
mProgressMax = aProgressMax;
}
NS_IMETHODIMP
OnProgressProxyEvent::HandleEvent()
{
return mProxy->mRealListener->OnProgress(mURL, mProgress, mProgressMax);
}
/*-------------- OnStatus Proxy --------------------------------------------*/
struct OnStatusProxyEvent : public StreamListenerProxyEvent
{
OnStatusProxyEvent(nsStreamListenerProxy* aProxy, nsIURI* aURL,
const PRUnichar* aMsg);
NS_IMETHOD HandleEvent();
PRUnichar* mMsg;
};
OnStatusProxyEvent::OnStatusProxyEvent(nsStreamListenerProxy* aProxy,
nsIURI* aURL,
const PRUnichar* aMsg)
: StreamListenerProxyEvent(aProxy, aURL)
{
mMsg = nsCRT::strdup(aMsg);
}
NS_IMETHODIMP
OnStatusProxyEvent::HandleEvent()
{
nsresult rv = mProxy->mRealListener->OnStatus(mURL, mMsg);
delete []mMsg;
mMsg = nsnull;
return rv;
}
/*-------------- OnStopRequest Proxy ---------------------------------------*/
struct OnStopRequestProxyEvent : public StreamListenerProxyEvent
{
OnStopRequestProxyEvent(nsStreamListenerProxy* aProxy, nsIURI* aURL,
nsresult aStatus, const PRUnichar* aMsg);
NS_IMETHOD HandleEvent();
nsresult mStatus;
PRUnichar* mMsg;
};
OnStopRequestProxyEvent::OnStopRequestProxyEvent(nsStreamListenerProxy* aProxy,
nsIURI* aURL,
nsresult aStatus,
const PRUnichar* aMsg)
: StreamListenerProxyEvent(aProxy, aURL)
{
mStatus = aStatus;
mMsg = nsCRT::strdup(aMsg);
}
NS_IMETHODIMP
OnStopRequestProxyEvent::HandleEvent()
{
nsresult rv = mProxy->mRealListener->OnStopRequest(mURL, mStatus, mMsg);
delete []mMsg;
mMsg = nsnull;
return rv;
}
/*-------------- OnDataAvailable Proxy -------------------------------------*/
struct OnDataAvailableProxyEvent : public StreamListenerProxyEvent
{
OnDataAvailableProxyEvent(nsStreamListenerProxy* aProxy, nsIURI* aURL,
nsIInputStream* aStream, PRUint32 aLength);
virtual ~OnDataAvailableProxyEvent();
NS_IMETHOD HandleEvent();
nsIInputStream* mStream;
PRUint32 mLength;
};
OnDataAvailableProxyEvent::OnDataAvailableProxyEvent(nsStreamListenerProxy* aProxy,
nsIURI* aURL,
nsIInputStream* aStream,
PRUint32 aLength)
: StreamListenerProxyEvent(aProxy, aURL)
{
mStream = aStream;
NS_ADDREF(mStream);
mLength = aLength;
}
OnDataAvailableProxyEvent::~OnDataAvailableProxyEvent()
{
NS_RELEASE(mStream);
}
NS_IMETHODIMP
OnDataAvailableProxyEvent::HandleEvent()
{
return mProxy->mRealListener->OnDataAvailable(mURL, mStream, mLength);
}
/*--------------------------------------------------------------------------*/
nsStreamListenerProxy::nsStreamListenerProxy(nsIStreamListener* aListener,
nsIEventQueue* aEventQ)
{
NS_INIT_REFCNT();
mRealListener = aListener;
NS_ADDREF(mRealListener);
mEventQ = aEventQ;
NS_IF_ADDREF(mEventQ);
mStatus = NS_OK;
}
void nsStreamListenerProxy::SetStatus(nsresult aStatus)
{
NS_LOCK_INSTANCE();
mStatus = aStatus;
NS_UNLOCK_INSTANCE();
}
nsresult nsStreamListenerProxy::GetStatus()
{
nsresult rv;
NS_LOCK_INSTANCE();
rv = mStatus;
NS_UNLOCK_INSTANCE();
return rv;
}
/*
* Implementation of threadsafe ISupports methods...
*/
static NS_DEFINE_IID(kIStreamListenerIID, NS_ISTREAMLISTENER_IID);
NS_IMPL_THREADSAFE_ISUPPORTS(nsStreamListenerProxy, kIStreamListenerIID);
NS_IMETHODIMP
nsStreamListenerProxy::OnStartRequest(nsIURI* aURL, const char *aContentType)
{
nsresult rv;
if (PR_GetCurrentThread() == gNetlibThread) {
OnStartRequestProxyEvent* ev;
rv = GetStatus();
if (NS_SUCCEEDED(rv)) {
ev = new OnStartRequestProxyEvent(this, aURL, aContentType);
if (nsnull == ev) {
rv = NS_ERROR_OUT_OF_MEMORY;
} else {
ev->Fire(mEventQ);
}
}
} else {
rv = mRealListener->OnStartRequest(aURL, aContentType);
}
return rv;
}
NS_IMETHODIMP
nsStreamListenerProxy::OnProgress(nsIURI* aURL, PRUint32 aProgress,
PRUint32 aProgressMax)
{
nsresult rv;
if (PR_GetCurrentThread() == gNetlibThread) {
OnProgressProxyEvent* ev;
/*
* Only fire the OnProgress notification if the connection is still valid.
* ie. A previous call did not fail...
*/
rv = GetStatus();
if (NS_SUCCEEDED(rv)) {
ev = new OnProgressProxyEvent(this, aURL, aProgress, aProgressMax);
if (nsnull == ev) {
rv = NS_ERROR_OUT_OF_MEMORY;
} else {
ev->Fire(mEventQ);
}
}
} else {
rv = mRealListener->OnProgress(aURL, aProgress, aProgressMax);
}
return rv;
}
NS_IMETHODIMP
nsStreamListenerProxy::OnStatus(nsIURI* aURL, const PRUnichar* aMsg)
{
nsresult rv;
if (PR_GetCurrentThread() == gNetlibThread) {
OnStatusProxyEvent* ev;
/*
* Only fire the OnStatus notification if the connection is still valid.
* ie. A previous call did not fail...
*/
rv = GetStatus();
if (NS_SUCCEEDED(rv)) {
ev = new OnStatusProxyEvent(this, aURL, aMsg);
if (nsnull == ev) {
rv = NS_ERROR_OUT_OF_MEMORY;
} else {
ev->Fire(mEventQ);
}
}
} else {
rv = mRealListener->OnStatus(aURL, aMsg);
}
return rv;
}
NS_IMETHODIMP
nsStreamListenerProxy::OnStopRequest(nsIURI* aURL, nsresult aStatus,
const PRUnichar* aMsg)
{
nsresult rv = NS_OK;
if (PR_GetCurrentThread() == gNetlibThread) {
OnStopRequestProxyEvent* ev;
/*
* Always fire the OnStopRequest notification...
*/
ev = new OnStopRequestProxyEvent(this, aURL, aStatus, aMsg);
if (nsnull == ev) {
rv = NS_ERROR_OUT_OF_MEMORY;
} else {
ev->Fire(mEventQ);
}
} else {
rv = mRealListener->OnStopRequest(aURL, aStatus, aMsg);
}
return rv;
}
/*--------------------------------------------------------------------------*/
NS_IMETHODIMP
nsStreamListenerProxy::GetBindInfo(nsIURI* aURL, nsStreamBindingInfo* info)
{
nsresult rv;
if (PR_GetCurrentThread() == gNetlibThread) {
PR_ASSERT(0);
rv = NS_ERROR_FAILURE;
} else {
rv = mRealListener->GetBindInfo(aURL, info);
}
return rv;
}
NS_IMETHODIMP
nsStreamListenerProxy::OnDataAvailable(nsIURI* aURL, nsIInputStream *aIStream,
PRUint32 aLength)
{
nsresult rv = NS_OK;
if (PR_GetCurrentThread() == gNetlibThread) {
OnDataAvailableProxyEvent* ev;
/*
* Only fire the OnDataAvailable notification if the connection is still valid.
* ie. A previous call did not fail...
*/
rv = GetStatus();
if (NS_SUCCEEDED(rv)) {
ev = new OnDataAvailableProxyEvent(this, aURL, aIStream, aLength);
if (nsnull == ev) {
rv = NS_ERROR_OUT_OF_MEMORY;
} else {
ev->Fire(mEventQ);
}
}
} else {
rv = mRealListener->OnDataAvailable(aURL, aIStream, aLength);
}
return rv;
}
/*--------------------------------------------------------------------------*/
nsStreamListenerProxy::~nsStreamListenerProxy()
{
NS_RELEASE(mRealListener);
NS_IF_RELEASE(mEventQ);
}
nsIStreamListener* ns_NewStreamListenerProxy(nsIStreamListener* aListener,
nsIEventQueue* aEventQ)
{
return new nsStreamListenerProxy(aListener, aEventQ);
}
/*----------- Proxy for net_CallExitRoutine(...) ---------------------------*/
extern "C" MODULE_PRIVATE void
net_CallExitRoutine(Net_GetUrlExitFunc* exit_routine,
URL_Struct* URL_s,
int status,
FO_Present_Types format_out,
MWContext* window_id);
struct CallExitRoutineProxyEvent : public ProxyEvent
{
CallExitRoutineProxyEvent(Net_GetUrlExitFunc* aExitRoutine,
URL_Struct* aURL_s,
int aStatus,
FO_Present_Types aFormatOut,
MWContext* aWindowId);
virtual ~CallExitRoutineProxyEvent();
NS_IMETHOD HandleEvent();
Net_GetUrlExitFunc* exit_routine;
URL_Struct* URL_s;
int status;
FO_Present_Types format_out;
MWContext* window_id;
};
CallExitRoutineProxyEvent::CallExitRoutineProxyEvent(Net_GetUrlExitFunc* aExitRoutine,
URL_Struct* aURL_s,
int aStatus,
FO_Present_Types aFormatOut,
MWContext* aWindowId)
{
exit_routine = aExitRoutine;
URL_s = aURL_s;
status = aStatus;
format_out = aFormatOut;
window_id = aWindowId;
net_AddrefContext(window_id);
NET_HoldURLStruct(URL_s);
}
CallExitRoutineProxyEvent::~CallExitRoutineProxyEvent()
{
NET_DropURLStruct(URL_s);
net_ReleaseContext(window_id);
}
NS_IMETHODIMP
CallExitRoutineProxyEvent::HandleEvent()
{
net_CallExitRoutine(exit_routine, URL_s, status, format_out, window_id);
return NS_OK;
}
extern "C" MODULE_PRIVATE void
net_CallExitRoutineProxy(Net_GetUrlExitFunc* exit_routine,
URL_Struct* URL_s,
int status,
FO_Present_Types format_out,
MWContext* window_id)
{
CallExitRoutineProxyEvent* ev;
/*
* Make sure that the URL_Struct was opened by the nsINetService...
* Otherwise, we cannot look at the URL_s->owner_data
*/
if (NULL != window_id->modular_data) {
/*
* Always use a PLEvent to call the exit_routine(...). This is necessary
* because when a connection is interrupted, the exit_routine(...) is called
* inside of the LIBNET_LOCK().
*
* By always using an event, we are sure that the exit_routine(...) is not
* called while the thread is holding the LIBNET_LOCK().
*/
ev = new CallExitRoutineProxyEvent(exit_routine, URL_s, status,
format_out, window_id);
if (nsnull != ev) {
nsIEventQueue* eventQueue = (nsIEventQueue*)(URL_s->owner_data);
if (eventQueue)
ev->Fire(eventQueue);
}
} else {
net_CallExitRoutine(exit_routine, URL_s, status, format_out, window_id);
}
}
Reference in New Issue View Git Blame Copy Permalink