From 019b53138d4fa6de8021ce2ab83aeaefdf6408c2 Mon Sep 17 00:00:00 2001 From: "darin%netscape.com" Date: Wed, 18 Jun 2003 23:07:09 +0000 Subject: [PATCH] fixes bug 204124 "minor codesize optimizations for nsNetUtil.h" r=dougt sr=alecf git-svn-id: svn://10.0.0.236/trunk@143896 18797224-902f-48f8-a5cc-f745e15eee43 --- mozilla/netwerk/base/public/nsNetUtil.h | 930 +++++++++++------------- 1 file changed, 431 insertions(+), 499 deletions(-) diff --git a/mozilla/netwerk/base/public/nsNetUtil.h b/mozilla/netwerk/base/public/nsNetUtil.h index a61ed156587..d5f5b5a162d 100644 --- a/mozilla/netwerk/base/public/nsNetUtil.h +++ b/mozilla/netwerk/base/public/nsNetUtil.h @@ -88,6 +88,18 @@ do_GetIOService(nsresult* error = 0) return nsGetServiceByCID(kIOServiceCID, 0, error); } +// private little helper function... don't call this directly! +inline nsresult +net_EnsureIOService(nsIIOService **ios, nsCOMPtr &grip) +{ + nsresult rv = NS_OK; + if (!*ios) { + grip = do_GetIOService(&rv); + *ios = grip; + } + return rv; +} + inline nsresult NS_NewURI(nsIURI **result, const nsACString &spec, @@ -96,15 +108,11 @@ NS_NewURI(nsIURI **result, nsIIOService *ioService = nsnull) // pass in nsIIOService to optimize callers { nsresult rv; - - nsCOMPtr serv; - if (ioService == nsnull) { - serv = do_GetIOService(&rv); - if (NS_FAILED(rv)) return rv; - ioService = serv.get(); - } - - return ioService->NewURI(spec, charset, baseURI, result); + nsCOMPtr grip; + rv = net_EnsureIOService(&ioService, grip); + if (ioService) + rv = ioService->NewURI(spec, charset, baseURI, result); + return rv; } inline nsresult @@ -132,52 +140,40 @@ NS_NewFileURI(nsIURI* *result, nsIIOService* ioService = nsnull) // pass in nsIIOService to optimize callers { nsresult rv; - - nsCOMPtr serv; - if (ioService == nsnull) { - serv = do_GetIOService(&rv); - if (NS_FAILED(rv)) return rv; - ioService = serv.get(); - } - - return ioService->NewFileURI(spec, result); + nsCOMPtr grip; + rv = net_EnsureIOService(&ioService, grip); + if (ioService) + rv = ioService->NewFileURI(spec, result); + return rv; } inline nsresult -NS_NewChannel(nsIChannel* *result, - nsIURI* uri, - nsIIOService* ioService = nsnull, // pass in nsIIOService to optimize callers - nsILoadGroup* loadGroup = nsnull, - nsIInterfaceRequestor* notificationCallbacks = nsnull, - nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIRequest::LOAD_NORMAL)) +NS_NewChannel(nsIChannel **result, + nsIURI *uri, + nsIIOService *ioService = nsnull, // pass in nsIIOService to optimize callers + nsILoadGroup *loadGroup = nsnull, + nsIInterfaceRequestor *callbacks = nsnull, + PRUint32 loadFlags = nsIRequest::LOAD_NORMAL) { nsresult rv; - - nsCOMPtr serv; - if (ioService == nsnull) { - serv = do_GetIOService(&rv); - if (NS_FAILED(rv)) return rv; - ioService = serv.get(); + nsCOMPtr grip; + rv = net_EnsureIOService(&ioService, grip); + if (ioService) { + nsIChannel *chan; + rv = ioService->NewChannelFromURI(uri, &chan); + if (NS_SUCCEEDED(rv)) { + if (loadGroup) + rv |= chan->SetLoadGroup(loadGroup); + if (callbacks) + rv |= chan->SetNotificationCallbacks(callbacks); + if (loadFlags != nsIRequest::LOAD_NORMAL) + rv |= chan->SetLoadFlags(loadFlags); + if (NS_SUCCEEDED(rv)) + *result = chan; + else + NS_RELEASE(chan); + } } - - nsIChannel* channel = nsnull; - rv = ioService->NewChannelFromURI(uri, &channel); - if (NS_FAILED(rv)) return rv; - - if (loadGroup) { - rv = channel->SetLoadGroup(loadGroup); - if (NS_FAILED(rv)) return rv; - } - if (notificationCallbacks) { - rv = channel->SetNotificationCallbacks(notificationCallbacks); - if (NS_FAILED(rv)) return rv; - } - if (loadAttributes != nsIRequest::LOAD_NORMAL) { - rv = channel->SetLoadFlags(loadAttributes); - if (NS_FAILED(rv)) return rv; - } - - *result = channel; return rv; } @@ -188,155 +184,146 @@ NS_NewChannel(nsIChannel* *result, // blown asyncrhonous consumer (via nsIStreamListener) // look at nsIStreamLoader instead. inline nsresult -NS_OpenURI(nsIInputStream* *result, - nsIURI* uri, - nsIIOService* ioService = nsnull, // pass in nsIIOService to optimize callers - nsILoadGroup* loadGroup = nsnull, - nsIInterfaceRequestor* notificationCallbacks = nsnull, - nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIRequest::LOAD_NORMAL)) +NS_OpenURI(nsIInputStream **result, + nsIURI *uri, + nsIIOService *ioService = nsnull, // pass in nsIIOService to optimize callers + nsILoadGroup *loadGroup = nsnull, + nsIInterfaceRequestor *callbacks = nsnull, + PRUint32 loadFlags = nsIRequest::LOAD_NORMAL) { nsresult rv; nsCOMPtr channel; - rv = NS_NewChannel(getter_AddRefs(channel), uri, ioService, - loadGroup, notificationCallbacks, loadAttributes); - if (NS_FAILED(rv)) return rv; - - nsIInputStream* inStr; - rv = channel->Open(&inStr); - if (NS_FAILED(rv)) return rv; - - *result = inStr; + loadGroup, callbacks, loadFlags); + if (NS_SUCCEEDED(rv)) { + nsIInputStream *stream; + rv = channel->Open(&stream); + if (NS_SUCCEEDED(rv)) + *result = stream; + } return rv; } inline nsresult -NS_OpenURI(nsIStreamListener* aConsumer, - nsISupports* context, - nsIURI* uri, - nsIIOService* ioService = nsnull, // pass in nsIIOService to optimize callers - nsILoadGroup* loadGroup = nsnull, - nsIInterfaceRequestor* notificationCallbacks = nsnull, - nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIRequest::LOAD_NORMAL)) +NS_OpenURI(nsIStreamListener *listener, + nsISupports *context, + nsIURI *uri, + nsIIOService *ioService = nsnull, // pass in nsIIOService to optimize callers + nsILoadGroup *loadGroup = nsnull, + nsIInterfaceRequestor *callbacks = nsnull, + PRUint32 loadFlags = nsIRequest::LOAD_NORMAL) { nsresult rv; nsCOMPtr channel; - rv = NS_NewChannel(getter_AddRefs(channel), uri, ioService, - loadGroup, notificationCallbacks, loadAttributes); - if (NS_FAILED(rv)) return rv; - - rv = channel->AsyncOpen(aConsumer, context); + loadGroup, callbacks, loadFlags); + if (NS_SUCCEEDED(rv)) + rv = channel->AsyncOpen(listener, context); return rv; } inline nsresult -NS_MakeAbsoluteURI(nsACString &result, +NS_MakeAbsoluteURI(nsACString &result, const nsACString &spec, - nsIURI *baseURI, - nsIIOService *ioService = nsnull) // pass in nsIIOService to optimize callers + nsIURI *baseURI, + nsIIOService *unused = nsnull) { - if (!baseURI) { - NS_WARNING("It doesn't make sense to not supply a base URI"); - result = spec; - return NS_OK; - } - - if (spec.IsEmpty()) - return baseURI->GetSpec(result); - - return baseURI->Resolve(spec, result); -} - -inline nsresult -NS_MakeAbsoluteURI(char **result, - const char *spec, - nsIURI *baseURI, - nsIIOService *ioService = nsnull) // pass in nsIIOService to optimize callers -{ - nsCAutoString resultBuf; - - nsresult rv = NS_MakeAbsoluteURI(resultBuf, nsDependentCString(spec), baseURI, ioService); - if (NS_FAILED(rv)) return rv; - - *result = ToNewCString(resultBuf); - return *result ? NS_OK : NS_ERROR_OUT_OF_MEMORY; -} - -inline nsresult -NS_MakeAbsoluteURI(nsAString &result, - const nsAString &spec, - nsIURI *baseURI, - nsIIOService *ioService = nsnull) // pass in nsIIOService to optimize callers -{ - if (!baseURI) { - NS_WARNING("It doesn't make sense to not supply a base URI"); - result = spec; - return NS_OK; - } - - nsCAutoString resultBuf; nsresult rv; - - if (spec.IsEmpty()) - rv = baseURI->GetSpec(resultBuf); + if (!baseURI) { + NS_WARNING("It doesn't make sense to not supply a base URI"); + result = spec; + rv = NS_OK; + } + else if (spec.IsEmpty()) + rv = baseURI->GetSpec(result); else - rv = baseURI->Resolve(NS_ConvertUCS2toUTF8(spec), resultBuf); - if (NS_FAILED(rv)) return rv; - - result = NS_ConvertUTF8toUCS2(resultBuf); // XXX CopyUTF8toUCS2 - return NS_OK; + rv = baseURI->Resolve(spec, result); + return rv; } inline nsresult -NS_NewInputStreamChannel(nsIChannel **result, - nsIURI *uri, - nsIInputStream *stream, - const nsACString &contentType = NS_LITERAL_CSTRING(""), +NS_MakeAbsoluteURI(char **result, + const char *spec, + nsIURI *baseURI, + nsIIOService *unused = nsnull) +{ + nsresult rv; + nsCAutoString resultBuf; + rv = NS_MakeAbsoluteURI(resultBuf, nsDependentCString(spec), baseURI); + if (NS_SUCCEEDED(rv)) { + *result = ToNewCString(resultBuf); + if (!*result) + rv = NS_ERROR_OUT_OF_MEMORY; + } + return rv; +} + +inline nsresult +NS_MakeAbsoluteURI(nsAString &result, + const nsAString &spec, + nsIURI *baseURI, + nsIIOService *unused = nsnull) +{ + nsresult rv; + if (!baseURI) { + NS_WARNING("It doesn't make sense to not supply a base URI"); + result = spec; + rv = NS_OK; + } + else { + nsCAutoString resultBuf; + if (spec.IsEmpty()) + rv = baseURI->GetSpec(resultBuf); + else + rv = baseURI->Resolve(NS_ConvertUCS2toUTF8(spec), resultBuf); + if (NS_SUCCEEDED(rv)) + CopyUTF8toUTF16(resultBuf, result); + } + return rv; +} + +inline nsresult +NS_NewInputStreamChannel(nsIChannel **result, + nsIURI *uri, + nsIInputStream *stream, + const nsACString &contentType = NS_LITERAL_CSTRING(""), const nsACString &contentCharset = NS_LITERAL_CSTRING("")) { nsresult rv; - static NS_DEFINE_CID(kInputStreamChannelCID, NS_INPUTSTREAMCHANNEL_CID); nsCOMPtr channel = do_CreateInstance(kInputStreamChannelCID, &rv); - if (NS_FAILED(rv)) return rv; - - 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; + if (NS_SUCCEEDED(rv)) { + rv |= channel->SetURI(uri); + rv |= channel->SetContentStream(stream); + rv |= channel->SetContentType(contentType); + rv |= channel->SetContentCharset(contentCharset); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*result = channel); + } + return rv; } inline nsresult NS_NewInputStreamPump(nsIInputStreamPump **result, - nsIInputStream *stream, - PRInt32 streamPos = -1, - PRInt32 streamLen = -1, - PRUint32 segsize = 0, - PRUint32 segcount = 0, - PRBool closeWhenDone = PR_FALSE) + nsIInputStream *stream, + PRInt32 streamPos = -1, + PRInt32 streamLen = -1, + PRUint32 segsize = 0, + PRUint32 segcount = 0, + PRBool closeWhenDone = PR_FALSE) { nsresult rv; - static NS_DEFINE_CID(kInputStreamPumpCID, NS_INPUTSTREAMPUMP_CID); nsCOMPtr pump = do_CreateInstance(kInputStreamPumpCID, &rv); - if (NS_FAILED(rv)) return rv; - - rv = pump->Init(stream, streamPos, streamLen, - segsize, segcount, closeWhenDone); - if (NS_FAILED(rv)) return rv; - - NS_ADDREF(*result = pump); - return NS_OK; + if (NS_SUCCEEDED(rv)) { + rv = pump->Init(stream, streamPos, streamLen, + segsize, segcount, closeWhenDone); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*result = pump); + } + return rv; } // NOTE: you can optimize the copy by specifying whether or not your streams @@ -345,347 +332,305 @@ NS_NewInputStreamPump(nsIInputStreamPump **result, // 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) + 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 copier = do_CreateInstance(kAsyncStreamCopierCID, &rv); - if (NS_FAILED(rv)) return rv; - - rv = copier->Init(source, sink, sourceBuffered, sinkBuffered, chunkSize); - if (NS_FAILED(rv)) return rv; - - NS_ADDREF(*result = copier); - return NS_OK; + if (NS_SUCCEEDED(rv)) { + rv = copier->Init(source, sink, sourceBuffered, sinkBuffered, chunkSize); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*result = copier); + } + return rv; } inline nsresult -NS_NewLoadGroup(nsILoadGroup* *result, nsIRequestObserver* obs) +NS_NewLoadGroup(nsILoadGroup **result, + nsIRequestObserver *obs) { nsresult rv; - nsCOMPtr group; static NS_DEFINE_CID(kLoadGroupCID, NS_LOADGROUP_CID); - rv = nsComponentManager::CreateInstance(kLoadGroupCID, nsnull, - NS_GET_IID(nsILoadGroup), - getter_AddRefs(group)); - if (NS_FAILED(rv)) return rv; - rv = group->SetGroupObserver(obs); - if (NS_FAILED(rv)) return rv; - - *result = group; - NS_ADDREF(*result); - return NS_OK; + nsCOMPtr group = + do_CreateInstance(kLoadGroupCID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = group->SetGroupObserver(obs); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*result = group); + } + return rv; } inline nsresult -NS_NewDownloader(nsIDownloader* *result, - nsIURI* uri, - nsIDownloadObserver* observer, - nsISupports* context = nsnull, - PRBool synchronous = PR_FALSE, - nsILoadGroup* loadGroup = nsnull, - nsIInterfaceRequestor* notificationCallbacks = nsnull, - nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIRequest::LOAD_NORMAL)) +NS_NewDownloader(nsIDownloader **result, + nsIURI *uri, + nsIDownloadObserver *observer, + nsISupports *context = nsnull, + PRBool synchronous = PR_FALSE, + nsILoadGroup *loadGroup = nsnull, + nsIInterfaceRequestor *callbacks = nsnull, + PRUint32 loadFlags = nsIRequest::LOAD_NORMAL) { nsresult rv; - nsCOMPtr downloader; static NS_DEFINE_CID(kDownloaderCID, NS_DOWNLOADER_CID); - rv = nsComponentManager::CreateInstance(kDownloaderCID, - nsnull, - NS_GET_IID(nsIDownloader), - getter_AddRefs(downloader)); - if (NS_FAILED(rv)) return rv; - rv = downloader->Init(uri, observer, context, synchronous, loadGroup, - notificationCallbacks, loadAttributes); - if (NS_FAILED(rv)) return rv; - *result = downloader; - NS_ADDREF(*result); + nsCOMPtr downloader = + do_CreateInstance(kDownloaderCID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = downloader->Init(uri, observer, context, synchronous, loadGroup, + callbacks, loadFlags); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*result = downloader); + } return rv; } inline nsresult -NS_NewStreamLoader(nsIStreamLoader **aResult, - nsIChannel *aChannel, +NS_NewStreamLoader(nsIStreamLoader **aResult, + nsIChannel *aChannel, nsIStreamLoaderObserver *aObserver, - nsISupports *aContext) + nsISupports *aContext) { nsresult rv; - nsCOMPtr loader; static NS_DEFINE_CID(kStreamLoaderCID, NS_STREAMLOADER_CID); - rv = nsComponentManager::CreateInstance(kStreamLoaderCID, - nsnull, - NS_GET_IID(nsIStreamLoader), - getter_AddRefs(loader)); - if (NS_FAILED(rv)) return rv; - - rv = loader->Init(aChannel, aObserver, aContext); - if (NS_FAILED(rv)) return rv; - - *aResult = loader; - NS_ADDREF(*aResult); + nsCOMPtr loader = + do_CreateInstance(kStreamLoaderCID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = loader->Init(aChannel, aObserver, aContext); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*aResult = loader); + } return rv; } inline nsresult -NS_NewStreamLoader(nsIStreamLoader* *result, - nsIURI* uri, - nsIStreamLoaderObserver* observer, - nsISupports* context = nsnull, - nsILoadGroup* loadGroup = nsnull, - nsIInterfaceRequestor* notificationCallbacks = nsnull, - nsLoadFlags loadAttributes = NS_STATIC_CAST(nsLoadFlags, nsIRequest::LOAD_NORMAL), - nsIURI* referrer = nsnull) +NS_NewStreamLoader(nsIStreamLoader **result, + nsIURI *uri, + nsIStreamLoaderObserver *observer, + nsISupports *context = nsnull, + nsILoadGroup *loadGroup = nsnull, + nsIInterfaceRequestor *callbacks = nsnull, + PRUint32 loadFlags = nsIRequest::LOAD_NORMAL, + nsIURI *referrer = nsnull) { nsresult rv; - nsCOMPtr channel; rv = NS_NewChannel(getter_AddRefs(channel), uri, nsnull, loadGroup, - notificationCallbacks, - loadAttributes); - if (NS_FAILED(rv)) return rv; - - nsCOMPtr httpChannel(do_QueryInterface(channel)); - if (httpChannel) - httpChannel->SetReferrer(referrer); - - return NS_NewStreamLoader(result, channel, observer, context); + callbacks, + loadFlags); + if (NS_SUCCEEDED(rv)) { + nsCOMPtr httpChannel(do_QueryInterface(channel)); + if (httpChannel) + httpChannel->SetReferrer(referrer); + rv = NS_NewStreamLoader(result, channel, observer, context); + } + return rv; } inline nsresult -NS_NewUnicharStreamLoader(nsIUnicharStreamLoader **aResult, - nsIChannel *aChannel, +NS_NewUnicharStreamLoader(nsIUnicharStreamLoader **aResult, + nsIChannel *aChannel, nsIUnicharStreamLoaderObserver *aObserver, - nsISupports *aContext = nsnull, - PRUint32 aSegmentSize = nsIUnicharStreamLoader::DEFAULT_SEGMENT_SIZE) + nsISupports *aContext = nsnull, + PRUint32 aSegmentSize = nsIUnicharStreamLoader::DEFAULT_SEGMENT_SIZE) { nsresult rv; - nsCOMPtr loader; static NS_DEFINE_CID(kUnicharStreamLoaderCID, NS_UNICHARSTREAMLOADER_CID); - rv = nsComponentManager::CreateInstance(kUnicharStreamLoaderCID, - nsnull, - NS_GET_IID(nsIUnicharStreamLoader), - getter_AddRefs(loader)); - if (NS_FAILED(rv)) return rv; - rv = loader->Init(aChannel, aObserver, aContext, aSegmentSize); - - if (NS_FAILED(rv)) return rv; - *aResult = loader; - NS_ADDREF(*aResult); + nsCOMPtr loader = + do_CreateInstance(kUnicharStreamLoaderCID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = loader->Init(aChannel, aObserver, aContext, aSegmentSize); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*aResult = loader); + } return rv; } inline nsresult NS_NewRequestObserverProxy(nsIRequestObserver **aResult, - nsIRequestObserver *aObserver, - nsIEventQueue *aEventQ=nsnull) + nsIRequestObserver *aObserver, + nsIEventQueue *aEventQ = nsnull) { - NS_ENSURE_ARG_POINTER(aResult); - nsresult rv; - nsCOMPtr proxy; static NS_DEFINE_CID(kRequestObserverProxyCID, NS_REQUESTOBSERVERPROXY_CID); - - rv = nsComponentManager::CreateInstance(kRequestObserverProxyCID, - nsnull, - NS_GET_IID(nsIRequestObserverProxy), - getter_AddRefs(proxy)); - if (NS_FAILED(rv)) return rv; - - rv = proxy->Init(aObserver, aEventQ); - if (NS_FAILED(rv)) return rv; - - return CallQueryInterface(proxy, aResult); + nsCOMPtr proxy = + do_CreateInstance(kRequestObserverProxyCID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = proxy->Init(aObserver, aEventQ); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*aResult = proxy); + } + return rv; } inline nsresult NS_NewSimpleStreamListener(nsIStreamListener **aResult, - nsIOutputStream *aSink, - nsIRequestObserver *aObserver=nsnull) + nsIOutputStream *aSink, + nsIRequestObserver *aObserver = nsnull) { - NS_ENSURE_ARG_POINTER(aResult); - nsresult rv; - nsCOMPtr listener; static NS_DEFINE_CID(kSimpleStreamListenerCID, NS_SIMPLESTREAMLISTENER_CID); - rv = nsComponentManager::CreateInstance(kSimpleStreamListenerCID, - nsnull, - NS_GET_IID(nsISimpleStreamListener), - getter_AddRefs(listener)); - if (NS_FAILED(rv)) return rv; - - rv = listener->Init(aSink, aObserver); - if (NS_FAILED(rv)) return rv; - - NS_ADDREF(*aResult = listener); - return NS_OK; + nsCOMPtr listener = + do_CreateInstance(kSimpleStreamListenerCID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = listener->Init(aSink, aObserver); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*aResult = listener); + } + return rv; } // Deprecated, prefer NS_NewStreamListenerProxy inline nsresult NS_NewAsyncStreamListener(nsIStreamListener **result, - nsIStreamListener *receiver, - nsIEventQueue *eventQueue) + nsIStreamListener *receiver, + nsIEventQueue *eventQueue) { nsresult rv; - nsCOMPtr lsnr; static NS_DEFINE_CID(kAsyncStreamListenerCID, NS_ASYNCSTREAMLISTENER_CID); - rv = nsComponentManager::CreateInstance(kAsyncStreamListenerCID, - nsnull, - NS_GET_IID(nsIAsyncStreamListener), - getter_AddRefs(lsnr)); - if (NS_FAILED(rv)) return rv; - rv = lsnr->Init(receiver, eventQueue); - if (NS_FAILED(rv)) return rv; - - NS_ADDREF(*result = lsnr); - return NS_OK; + nsCOMPtr lsnr = + do_CreateInstance(kAsyncStreamListenerCID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = lsnr->Init(receiver, eventQueue); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*result = lsnr); + } + return rv; } inline nsresult -NS_CheckPortSafety(PRInt32 port, const char* scheme, nsIIOService* ioService = nsnull) +NS_CheckPortSafety(PRInt32 port, + const char *scheme, + nsIIOService *ioService = nsnull) { nsresult rv; - - nsCOMPtr serv; - if (ioService == nsnull) { - serv = do_GetIOService(&rv); - if (NS_FAILED(rv)) return rv; - ioService = serv.get(); + nsCOMPtr grip; + rv = net_EnsureIOService(&ioService, grip); + if (ioService) { + PRBool allow; + rv = ioService->AllowPort(port, scheme, &allow); + if (NS_SUCCEEDED(rv) && !allow) + rv = NS_ERROR_PORT_ACCESS_NOT_ALLOWED; } - - PRBool allow; - - rv = ioService->AllowPort(port, scheme, &allow); - if (NS_FAILED(rv)) { - NS_ERROR("NS_CheckPortSafety: ioService->AllowPort failed\n"); - return rv; - } - - if (!allow) - return NS_ERROR_PORT_ACCESS_NOT_ALLOWED; - - return NS_OK; + return rv; } inline nsresult -NS_NewProxyInfo(const char* type, const char* host, PRInt32 port, nsIProxyInfo* *result) +NS_NewProxyInfo(const char *type, + const char *host, + PRInt32 port, + nsIProxyInfo **result) { nsresult rv; - static NS_DEFINE_CID(kPPSServiceCID, NS_PROTOCOLPROXYSERVICE_CID); - nsCOMPtr pps = do_GetService(kPPSServiceCID,&rv); - - if (NS_FAILED(rv)) return rv; - - return pps->NewProxyInfo(type, host, port, result); + nsCOMPtr pps = do_GetService(kPPSServiceCID, &rv); + if (NS_SUCCEEDED(rv)) + rv = pps->NewProxyInfo(type, host, port, result); + return rv; } inline nsresult NS_GetFileProtocolHandler(nsIFileProtocolHandler **result, - nsIIOService *ioService=nsnull) + nsIIOService *ioService = nsnull) { nsresult rv; - - nsCOMPtr serv; - if (ioService == nsnull) { - serv = do_GetIOService(&rv); - if (NS_FAILED(rv)) return rv; - ioService = serv.get(); + nsCOMPtr grip; + rv = net_EnsureIOService(&ioService, grip); + if (ioService) { + nsCOMPtr handler; + rv = ioService->GetProtocolHandler("file", getter_AddRefs(handler)); + if (NS_SUCCEEDED(rv)) + rv = CallQueryInterface(handler, result); } - - nsCOMPtr handler; - rv = ioService->GetProtocolHandler("file", getter_AddRefs(handler)); - if (NS_FAILED(rv)) return rv; - - return CallQueryInterface(handler, result); + return rv; } inline nsresult -NS_GetFileFromURLSpec(const nsACString &inURL, nsIFile **result, - nsIIOService *ioService=nsnull) +NS_GetFileFromURLSpec(const nsACString &inURL, + nsIFile **result, + nsIIOService *ioService = nsnull) { + nsresult rv; nsCOMPtr fileHandler; - nsresult rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler), ioService); - if (NS_FAILED(rv)) return rv; - - return fileHandler->GetFileFromURLSpec(inURL, result); + rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler), ioService); + if (NS_SUCCEEDED(rv)) + rv = fileHandler->GetFileFromURLSpec(inURL, result); + return rv; } inline nsresult -NS_GetURLSpecFromFile(nsIFile* aFile, nsACString &aUrl, - nsIIOService *ioService=nsnull) +NS_GetURLSpecFromFile(nsIFile *aFile, + nsACString &aUrl, + nsIIOService *ioService = nsnull) { + nsresult rv; nsCOMPtr fileHandler; - nsresult rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler), ioService); - if (NS_FAILED(rv)) return rv; - - return fileHandler->GetURLSpecFromFile(aFile, aUrl); + rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler), ioService); + if (NS_SUCCEEDED(rv)) + rv = fileHandler->GetURLSpecFromFile(aFile, aUrl); + return rv; } inline nsresult -NS_NewResumableEntityID(nsIResumableEntityID** aRes, - PRUint32 size, - PRTime lastModified) +NS_NewResumableEntityID(nsIResumableEntityID **aRes, + PRUint32 size, + PRTime lastModified) { nsresult rv; nsCOMPtr ent = do_CreateInstance(NS_RESUMABLEENTITYID_CONTRACTID,&rv); - if (NS_FAILED(rv)) return rv; - - ent->SetSize(size); - ent->SetLastModified(lastModified); - - *aRes = ent; - NS_ADDREF(*aRes); - return NS_OK; + if (NS_SUCCEEDED(rv)) { + ent->SetSize(size); + ent->SetLastModified(lastModified); + NS_ADDREF(*aRes = ent); + } + return rv; } inline nsresult -NS_ExamineForProxy(const char* scheme, const char* host, PRInt32 port, - nsIProxyInfo* *proxyInfo) +NS_ExamineForProxy(const char *scheme, + const char *host, + PRInt32 port, + nsIProxyInfo **proxyInfo) { nsresult rv; - static NS_DEFINE_CID(kPPSServiceCID, NS_PROTOCOLPROXYSERVICE_CID); - nsCOMPtr pps = do_GetService(kPPSServiceCID,&rv); - - if (NS_FAILED(rv)) return rv; - - nsCAutoString spec(scheme); - spec.Append("://"); - spec.Append(host); - spec.Append(':'); - spec.AppendInt(port); - - // XXXXX - Under no circumstances whatsoever should any code which - // wants a uri do this. I do this here because I do not, in fact, - // actually want a uri (the dummy uris created here may not be - // syntactically valid for the specific protocol), and all we need - // is something which has a valid scheme, hostname, and a string - // to pass to PAC if needed - bbaetz - static NS_DEFINE_CID(kSTDURLCID, NS_STANDARDURL_CID); - nsCOMPtr uri = do_CreateInstance(kSTDURLCID, &rv); - if (NS_FAILED(rv)) return rv; - rv = uri->SetSpec(spec); - if (NS_FAILED(rv)) return rv; - - return pps->ExamineForProxy(uri, proxyInfo); + nsCOMPtr pps = do_GetService(kPPSServiceCID, &rv); + if (NS_SUCCEEDED(rv)) { + nsCAutoString spec(scheme); + spec.Append("://"); + spec.Append(host); + spec.Append(':'); + spec.AppendInt(port); + // XXXXX - Under no circumstances whatsoever should any code which + // wants a uri do this. I do this here because I do not, in fact, + // actually want a uri (the dummy uris created here may not be + // syntactically valid for the specific protocol), and all we need + // is something which has a valid scheme, hostname, and a string + // to pass to PAC if needed - bbaetz + static NS_DEFINE_CID(kStandardURLCID, NS_STANDARDURL_CID); + nsCOMPtr uri = do_CreateInstance(kStandardURLCID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = uri->SetSpec(spec); + if (NS_SUCCEEDED(rv)) + rv = pps->ExamineForProxy(uri, proxyInfo); + } + } + return rv; } inline nsresult NS_ParseContentType(const nsACString &rawContentType, - nsCString &contentType, - nsCString &contentCharset) + nsCString &contentType, + nsCString &contentCharset) { // contentCharset is left untouched if not present in rawContentType nsACString::const_iterator begin, it, end; @@ -708,164 +653,151 @@ NS_ParseContentType(const nsACString &rawContentType, } inline nsresult -NS_NewLocalFileInputStream(nsIInputStream** aResult, - nsIFile* aFile, - PRInt32 aIOFlags = -1, - PRInt32 aPerm = -1, - PRInt32 aBehaviorFlags = 0) +NS_NewLocalFileInputStream(nsIInputStream **aResult, + nsIFile *aFile, + PRInt32 aIOFlags = -1, + PRInt32 aPerm = -1, + PRInt32 aBehaviorFlags = 0) { nsresult rv; - nsCOMPtr 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; + nsCOMPtr in = + do_CreateInstance(kLocalFileInputStreamCID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = in->Init(aFile, aIOFlags, aPerm, aBehaviorFlags); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*aResult = in); + } + return rv; } inline nsresult -NS_NewLocalFileOutputStream(nsIOutputStream** aResult, - nsIFile* aFile, - PRInt32 aIOFlags = -1, - PRInt32 aPerm = -1, - PRInt32 aBehaviorFlags = 0) +NS_NewLocalFileOutputStream(nsIOutputStream **aResult, + nsIFile *aFile, + PRInt32 aIOFlags = -1, + PRInt32 aPerm = -1, + PRInt32 aBehaviorFlags = 0) { nsresult rv; - nsCOMPtr 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; + nsCOMPtr out = + do_CreateInstance(kLocalFileOutputStreamCID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = out->Init(aFile, aIOFlags, aPerm, aBehaviorFlags); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*aResult = out); + } + return rv; } +// returns the input end of a pipe. the output end of the pipe +// is attached to the original stream. data from the original +// stream is read into the pipe on a background thread. inline nsresult -NS_BackgroundInputStream(nsIInputStream** aResult, - nsIInputStream* aStream, - PRUint32 aSegmentSize = 0, - PRUint32 aSegmentCount = 0) +NS_BackgroundInputStream(nsIInputStream **aResult, + nsIInputStream *aStream, + PRUint32 aSegmentSize = 0, + PRUint32 aSegmentCount = 0) { nsresult rv; - nsCOMPtr sts = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv); - if (NS_FAILED(rv)) - return rv; - - nsCOMPtr inTransport; - rv = sts->CreateInputTransport(aStream, -1, -1, PR_TRUE, - getter_AddRefs(inTransport)); - if (NS_FAILED(rv)) - return rv; - - return inTransport->OpenInputStream(nsITransport::OPEN_BLOCKING, - aSegmentSize, aSegmentCount, aResult); + if (NS_SUCCEEDED(rv)) { + nsCOMPtr inTransport; + rv = sts->CreateInputTransport(aStream, -1, -1, PR_TRUE, + getter_AddRefs(inTransport)); + if (NS_SUCCEEDED(rv)) + rv = inTransport->OpenInputStream(nsITransport::OPEN_BLOCKING, + aSegmentSize, aSegmentCount, + aResult); + } + return rv; } +// returns the output end of a pipe. the input end of the pipe +// is attached to the original stream. data written to the pipe +// is copied to the original stream on a background thread. inline nsresult -NS_BackgroundOutputStream(nsIOutputStream** aResult, - nsIOutputStream* aStream, - PRUint32 aSegmentSize = 0, - PRUint32 aSegmentCount = 0) +NS_BackgroundOutputStream(nsIOutputStream **aResult, + nsIOutputStream *aStream, + PRUint32 aSegmentSize = 0, + PRUint32 aSegmentCount = 0) { nsresult rv; - nsCOMPtr sts = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv); - if (NS_FAILED(rv)) - return rv; - - nsCOMPtr inTransport; - rv = sts->CreateOutputTransport(aStream, -1, -1, PR_TRUE, - getter_AddRefs(inTransport)); - if (NS_FAILED(rv)) - return rv; - - return inTransport->OpenOutputStream(nsITransport::OPEN_BLOCKING, - aSegmentSize, aSegmentCount, aResult); + if (NS_SUCCEEDED(rv)) { + nsCOMPtr inTransport; + rv = sts->CreateOutputTransport(aStream, -1, -1, PR_TRUE, + getter_AddRefs(inTransport)); + if (NS_SUCCEEDED(rv)) + rv = inTransport->OpenOutputStream(nsITransport::OPEN_BLOCKING, + aSegmentSize, aSegmentCount, + aResult); + } + return rv; } inline nsresult -NS_NewBufferedInputStream(nsIInputStream** aResult, - nsIInputStream* aStr, - PRUint32 aBufferSize) +NS_NewBufferedInputStream(nsIInputStream **aResult, + nsIInputStream *aStr, + PRUint32 aBufferSize) { nsresult rv; - nsCOMPtr 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; + nsCOMPtr in = + do_CreateInstance(kBufferedInputStreamCID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = in->Init(aStr, aBufferSize); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*aResult = in); + } + return rv; } inline nsresult -NS_NewBufferedOutputStream(nsIOutputStream** aResult, - nsIOutputStream* aStr, - PRUint32 aBufferSize) +NS_NewBufferedOutputStream(nsIOutputStream **aResult, + nsIOutputStream *aStr, + PRUint32 aBufferSize) { nsresult rv; - nsCOMPtr 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; + nsCOMPtr out = + do_CreateInstance(kBufferedOutputStreamCID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = out->Init(aStr, aBufferSize); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*aResult = out); + } + return rv; } +// returns an input stream compatible with nsIUploadChannel::SetUploadStream() inline nsresult -NS_NewPostDataStream(nsIInputStream **result, - PRBool isFile, +NS_NewPostDataStream(nsIInputStream **result, + PRBool isFile, const nsACString &data, - PRUint32 encodeFlags, - nsIIOService* ioService = nsnull) // pass in nsIIOService to optimize callers + PRUint32 encodeFlags, + nsIIOService *unused = nsnull) { - nsresult rv; - if (isFile) { + nsresult rv; nsCOMPtr file; nsCOMPtr 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); + if (NS_SUCCEEDED(rv)) { + rv = NS_NewLocalFileInputStream(getter_AddRefs(fileStream), file); + if (NS_SUCCEEDED(rv)) { + // wrap the file stream with a buffered input stream + rv = NS_NewBufferedInputStream(result, fileStream, 8192); + } + } + return rv; } - // otherwise, create a string stream for the data + // otherwise, create a string stream for the data (copies) return NS_NewCStringInputStream(result, data); } -#endif // nsNetUtil_h__ +#endif // !nsNetUtil_h__