summaryrefslogtreecommitdiffstats
path: root/netwerk/base/nsNetUtilInlines.h
diff options
context:
space:
mode:
Diffstat (limited to 'netwerk/base/nsNetUtilInlines.h')
-rw-r--r--netwerk/base/nsNetUtilInlines.h395
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