diff options
Diffstat (limited to 'netwerk/base/nsNetUtilInlines.h')
| -rw-r--r-- | netwerk/base/nsNetUtilInlines.h | 395 |
1 files changed, 395 insertions, 0 deletions
diff --git a/netwerk/base/nsNetUtilInlines.h b/netwerk/base/nsNetUtilInlines.h new file mode 100644 index 000000000..7003814d5 --- /dev/null +++ b/netwerk/base/nsNetUtilInlines.h @@ -0,0 +1,395 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* vim:set ts=4 sw=4 sts=4 et cin: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef nsNetUtil_inl +#define nsNetUtil_inl + +#include "mozilla/Services.h" + +#include "nsComponentManagerUtils.h" +#include "nsIBufferedStreams.h" +#include "nsIChannel.h" +#include "nsIFile.h" +#include "nsIFileStreams.h" +#include "nsIFileURL.h" +#include "nsIHttpChannel.h" +#include "nsIInputStreamChannel.h" +#include "nsIIOService.h" +#include "nsINestedURI.h" +#include "nsINode.h" +#include "nsIProtocolHandler.h" +#include "nsIStandardURL.h" +#include "nsIStreamLoader.h" +#include "nsIIncrementalStreamLoader.h" +#include "nsIURI.h" +#include "nsIURIWithPrincipal.h" +#include "nsIWritablePropertyBag2.h" +#include "nsNetCID.h" +#include "nsStringStream.h" + +#ifdef MOZILLA_INTERNAL_API +// Don't allow functions that end up in nsNetUtil.cpp to be inlined out. +#define INLINE_IF_EXTERN MOZ_NEVER_INLINE +#else +// Make sure that functions included via nsNetUtil.h don't get multiply defined. +#define INLINE_IF_EXTERN MOZ_ALWAYS_INLINE +#endif + +#ifdef MOZILLA_INTERNAL_API + +INLINE_IF_EXTERN already_AddRefed<nsIIOService> +do_GetIOService(nsresult *error /* = 0 */) +{ + nsCOMPtr<nsIIOService> io = mozilla::services::GetIOService(); + if (error) + *error = io ? NS_OK : NS_ERROR_FAILURE; + return io.forget(); +} + +INLINE_IF_EXTERN already_AddRefed<nsINetUtil> +do_GetNetUtil(nsresult *error /* = 0 */) +{ + nsCOMPtr<nsIIOService> io = mozilla::services::GetIOService(); + nsCOMPtr<nsINetUtil> util; + if (io) + util = do_QueryInterface(io); + + if (error) + *error = !!util ? NS_OK : NS_ERROR_FAILURE; + return util.forget(); +} + +#else + +INLINE_IF_EXTERN const nsGetServiceByContractIDWithError +do_GetIOService(nsresult *error /* = 0 */) +{ + return nsGetServiceByContractIDWithError(NS_IOSERVICE_CONTRACTID, error); +} + +INLINE_IF_EXTERN const nsGetServiceByContractIDWithError +do_GetNetUtil(nsresult *error /* = 0 */) +{ + return do_GetIOService(error); +} +#endif + +// private little helper function... don't call this directly! +MOZ_ALWAYS_INLINE nsresult +net_EnsureIOService(nsIIOService **ios, nsCOMPtr<nsIIOService> &grip) +{ + nsresult rv = NS_OK; + if (!*ios) { + grip = do_GetIOService(&rv); + *ios = grip; + } + return rv; +} + +INLINE_IF_EXTERN nsresult +NS_URIChainHasFlags(nsIURI *uri, + uint32_t flags, + bool *result) +{ + nsresult rv; + nsCOMPtr<nsINetUtil> util = do_GetNetUtil(&rv); + NS_ENSURE_SUCCESS(rv, rv); + + return util->URIChainHasFlags(uri, flags, result); +} + +INLINE_IF_EXTERN nsresult +NS_NewURI(nsIURI **result, + const nsACString &spec, + const char *charset /* = nullptr */, + nsIURI *baseURI /* = nullptr */, + nsIIOService *ioService /* = nullptr */) // pass in nsIIOService to optimize callers +{ + nsresult rv; + nsCOMPtr<nsIIOService> grip; + rv = net_EnsureIOService(&ioService, grip); + if (ioService) + rv = ioService->NewURI(spec, charset, baseURI, result); + return rv; +} + +INLINE_IF_EXTERN nsresult +NS_NewURI(nsIURI **result, + const nsAString &spec, + const char *charset /* = nullptr */, + nsIURI *baseURI /* = nullptr */, + nsIIOService *ioService /* = nullptr */) // pass in nsIIOService to optimize callers +{ + return NS_NewURI(result, NS_ConvertUTF16toUTF8(spec), charset, baseURI, ioService); +} + +INLINE_IF_EXTERN nsresult +NS_NewURI(nsIURI **result, + const char *spec, + nsIURI *baseURI /* = nullptr */, + nsIIOService *ioService /* = nullptr */) // pass in nsIIOService to optimize callers +{ + return NS_NewURI(result, nsDependentCString(spec), nullptr, baseURI, ioService); +} + +INLINE_IF_EXTERN nsresult +NS_NewFileURI(nsIURI **result, + nsIFile *spec, + nsIIOService *ioService /* = nullptr */) // pass in nsIIOService to optimize callers +{ + nsresult rv; + nsCOMPtr<nsIIOService> grip; + rv = net_EnsureIOService(&ioService, grip); + if (ioService) + rv = ioService->NewFileURI(spec, result); + return rv; +} + +INLINE_IF_EXTERN nsresult +NS_NewChannelInternal(nsIChannel **outChannel, + nsIURI *aUri, + nsINode *aLoadingNode, + nsIPrincipal *aLoadingPrincipal, + nsIPrincipal *aTriggeringPrincipal, + nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + nsILoadGroup *aLoadGroup /* = nullptr */, + nsIInterfaceRequestor *aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */, + nsIIOService *aIoService /* = nullptr */) +{ + NS_ENSURE_ARG_POINTER(outChannel); + + nsCOMPtr<nsIIOService> grip; + nsresult rv = net_EnsureIOService(&aIoService, grip); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIChannel> channel; + rv = aIoService->NewChannelFromURI2( + aUri, + aLoadingNode ? + aLoadingNode->AsDOMNode() : nullptr, + aLoadingPrincipal, + aTriggeringPrincipal, + aSecurityFlags, + aContentPolicyType, + getter_AddRefs(channel)); + NS_ENSURE_SUCCESS(rv, rv); + + if (aLoadGroup) { + rv = channel->SetLoadGroup(aLoadGroup); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (aCallbacks) { + rv = channel->SetNotificationCallbacks(aCallbacks); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (aLoadFlags != nsIRequest::LOAD_NORMAL) { + // Retain the LOAD_REPLACE load flag if set. + nsLoadFlags normalLoadFlags = 0; + channel->GetLoadFlags(&normalLoadFlags); + rv = channel->SetLoadFlags(aLoadFlags | (normalLoadFlags & nsIChannel::LOAD_REPLACE)); + NS_ENSURE_SUCCESS(rv, rv); + } + + channel.forget(outChannel); + return NS_OK; +} + +INLINE_IF_EXTERN nsresult +NS_NewChannelInternal(nsIChannel **outChannel, + nsIURI *aUri, + nsILoadInfo *aLoadInfo, + nsILoadGroup *aLoadGroup /* = nullptr */, + nsIInterfaceRequestor *aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */, + nsIIOService *aIoService /* = nullptr */) +{ + // NS_NewChannelInternal is mostly called for channel redirects. We should allow + // the creation of a channel even if the original channel did not have a loadinfo + // attached. + NS_ENSURE_ARG_POINTER(outChannel); + + nsCOMPtr<nsIIOService> grip; + nsresult rv = net_EnsureIOService(&aIoService, grip); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIChannel> channel; + rv = aIoService->NewChannelFromURIWithLoadInfo( + aUri, + aLoadInfo, + getter_AddRefs(channel)); + NS_ENSURE_SUCCESS(rv, rv); + + if (aLoadGroup) { + rv = channel->SetLoadGroup(aLoadGroup); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (aCallbacks) { + rv = channel->SetNotificationCallbacks(aCallbacks); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (aLoadFlags != nsIRequest::LOAD_NORMAL) { + // Retain the LOAD_REPLACE load flag if set. + nsLoadFlags normalLoadFlags = 0; + channel->GetLoadFlags(&normalLoadFlags); + rv = channel->SetLoadFlags(aLoadFlags | (normalLoadFlags & nsIChannel::LOAD_REPLACE)); + NS_ENSURE_SUCCESS(rv, rv); + } + + channel.forget(outChannel); + return NS_OK; +} + +INLINE_IF_EXTERN nsresult /* NS_NewChannelPrincipal */ +NS_NewChannel(nsIChannel **outChannel, + nsIURI *aUri, + nsIPrincipal *aLoadingPrincipal, + nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + nsILoadGroup *aLoadGroup /* = nullptr */, + nsIInterfaceRequestor *aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */, + nsIIOService *aIoService /* = nullptr */) +{ + return NS_NewChannelInternal(outChannel, + aUri, + nullptr, // aLoadingNode, + aLoadingPrincipal, + nullptr, // aTriggeringPrincipal + aSecurityFlags, + aContentPolicyType, + aLoadGroup, + aCallbacks, + aLoadFlags, + aIoService); +} + +INLINE_IF_EXTERN nsresult +NS_NewStreamLoader(nsIStreamLoader **result, + nsIStreamLoaderObserver *observer, + nsIRequestObserver *requestObserver /* = nullptr */) +{ + nsresult rv; + nsCOMPtr<nsIStreamLoader> loader = + do_CreateInstance(NS_STREAMLOADER_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = loader->Init(observer, requestObserver); + if (NS_SUCCEEDED(rv)) { + *result = nullptr; + loader.swap(*result); + } + } + return rv; +} + +INLINE_IF_EXTERN nsresult +NS_NewLocalFileInputStream(nsIInputStream **result, + nsIFile *file, + int32_t ioFlags /* = -1 */, + int32_t perm /* = -1 */, + int32_t behaviorFlags /* = 0 */) +{ + nsresult rv; + nsCOMPtr<nsIFileInputStream> in = + do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = in->Init(file, ioFlags, perm, behaviorFlags); + if (NS_SUCCEEDED(rv)) + in.forget(result); + } + return rv; +} + +INLINE_IF_EXTERN nsresult +NS_NewLocalFileOutputStream(nsIOutputStream **result, + nsIFile *file, + int32_t ioFlags /* = -1 */, + int32_t perm /* = -1 */, + int32_t behaviorFlags /* = 0 */) +{ + nsresult rv; + nsCOMPtr<nsIFileOutputStream> out = + do_CreateInstance(NS_LOCALFILEOUTPUTSTREAM_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = out->Init(file, ioFlags, perm, behaviorFlags); + if (NS_SUCCEEDED(rv)) + out.forget(result); + } + return rv; +} + +INLINE_IF_EXTERN MOZ_MUST_USE nsresult +NS_NewBufferedInputStream(nsIInputStream **result, + nsIInputStream *str, + uint32_t bufferSize) +{ + nsresult rv; + nsCOMPtr<nsIBufferedInputStream> in = + do_CreateInstance(NS_BUFFEREDINPUTSTREAM_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = in->Init(str, bufferSize); + if (NS_SUCCEEDED(rv)) { + in.forget(result); + } + } + return rv; +} + +INLINE_IF_EXTERN nsresult +NS_NewPostDataStream(nsIInputStream **result, + bool isFile, + const nsACString &data) +{ + nsresult rv; + + if (isFile) { + nsCOMPtr<nsIFile> file; + nsCOMPtr<nsIInputStream> fileStream; + + rv = NS_NewNativeLocalFile(data, false, getter_AddRefs(file)); + 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 (copies) + nsCOMPtr<nsIStringInputStream> stream + (do_CreateInstance("@mozilla.org/io/string-input-stream;1", &rv)); + if (NS_FAILED(rv)) + return rv; + + rv = stream->SetData(data.BeginReading(), data.Length()); + if (NS_FAILED(rv)) + return rv; + + stream.forget(result); + return NS_OK; +} + +INLINE_IF_EXTERN bool +NS_IsOffline() +{ + bool offline = true; + bool connectivity = true; + nsCOMPtr<nsIIOService> ios = do_GetIOService(); + if (ios) { + ios->GetOffline(&offline); + ios->GetConnectivity(&connectivity); + } + return offline || !connectivity; +} + +#endif // nsNetUtil_inl |