wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 1038756: Extend nsNetutil to include requestingPrincipal, requestingNode, and contentPolicyType (r=mcmanus)

Browse Source
This commit is contained in:
Christoph Kerschbaumer 2014-07-17 14:52:25 -07:00
parent 3e0164ca53
commit 86ac863b72
1 changed files with 410 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

542
netwerk/base/public/nsNetUtil.h
View File

@ -83,6 +83,8 @@
#include "nsCategoryCache.h" #include "nsCategoryCache.h"
#include "nsStringStream.h" #include "nsStringStream.h"
#include "nsIViewSourceChannel.h" #include "nsIViewSourceChannel.h"
#include "mozilla/LoadInfo.h"
#include "nsINode.h"
#include <limits> #include <limits>
@ -186,54 +188,150 @@ NS_NewFileURI(nsIURI* *result,
return rv; return rv;
} }
/*
* How to create a new Channel using NS_NewChannel:
* 1) Please try to call NS_NewChannel providing a requesting *nsINode*
* 2) If no requesting nsINode is available,
* call NS_NewChannel providing a requesting *nsIPrincipal*.
* 3) Call NS_NewChannelInternal *only* if requesting Principal and
* the Node's Principal have to be different.
* >> Most likely this is not the case! <<
* Needs special approval!
*/
inline nsresult inline nsresult
NS_NewChannel(nsIChannel **result, NS_NewChannelInternal(nsIChannel** outChannel,
nsIURI *uri, nsIURI* aUri,
nsIIOService *ioService = nullptr, // pass in nsIIOService to optimize callers nsILoadInfo* aLoadInfo,
nsILoadGroup *loadGroup = nullptr, nsIChannelPolicy* aChannelPolicy = nullptr,
nsIInterfaceRequestor *callbacks = nullptr, nsILoadGroup* aLoadGroup = nullptr,
uint32_t loadFlags = nsIRequest::LOAD_NORMAL, nsIInterfaceRequestor* aCallbacks = nullptr,
nsIChannelPolicy *channelPolicy = nullptr) nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL,
nsIIOService* aIoService = nullptr)
{ {
nsresult rv; NS_ASSERTION(aLoadInfo, "Can not create channel without aLoadInfo!");
nsCOMPtr<nsIIOService> grip; NS_ENSURE_ARG_POINTER(outChannel);
rv = net_EnsureIOService(&ioService, grip);
if (ioService) { nsCOMPtr<nsIIOService> grip;
nsCOMPtr<nsIChannel> chan; nsresult rv = net_EnsureIOService(&aIoService, grip);
rv = ioService->NewChannelFromURI(uri, getter_AddRefs(chan)); NS_ENSURE_SUCCESS(rv, rv);
if (NS_SUCCEEDED(rv)) {
if (loadGroup) { nsCOMPtr<nsIChannel> channel;
rv = chan->SetLoadGroup(loadGroup); rv = aIoService->NewChannelFromURI(aUri, getter_AddRefs(channel));
} NS_ENSURE_SUCCESS(rv, rv);
if (callbacks) {
nsresult tmp = chan->SetNotificationCallbacks(callbacks); if (aLoadGroup) {
if (NS_FAILED(tmp)) { rv = channel->SetLoadGroup(aLoadGroup);
rv = tmp; NS_ENSURE_SUCCESS(rv, rv);
} }
}
if (loadFlags != nsIRequest::LOAD_NORMAL) { if (aCallbacks) {
// Retain the LOAD_REPLACE load flag if set. rv = channel->SetNotificationCallbacks(aCallbacks);
nsLoadFlags normalLoadFlags = 0; NS_ENSURE_SUCCESS(rv, rv);
chan->GetLoadFlags(&normalLoadFlags); }
nsresult tmp = chan->SetLoadFlags(loadFlags |
(normalLoadFlags & if (aLoadFlags != nsIRequest::LOAD_NORMAL) {
nsIChannel::LOAD_REPLACE)); // Retain the LOAD_REPLACE load flag if set.
if (NS_FAILED(tmp)) { nsLoadFlags normalLoadFlags = 0;
rv = tmp; channel->GetLoadFlags(&normalLoadFlags);
} rv = channel->SetLoadFlags(aLoadFlags | (normalLoadFlags & nsIChannel::LOAD_REPLACE));
} NS_ENSURE_SUCCESS(rv, rv);
if (channelPolicy) { }
nsCOMPtr<nsIWritablePropertyBag2> props = do_QueryInterface(chan);
if (props) { if (aChannelPolicy) {
props->SetPropertyAsInterface(NS_CHANNEL_PROP_CHANNEL_POLICY, nsCOMPtr<nsIWritablePropertyBag2> props = do_QueryInterface(channel);
channelPolicy); if (props) {
} props->SetPropertyAsInterface(NS_CHANNEL_PROP_CHANNEL_POLICY, aChannelPolicy);
}
if (NS_SUCCEEDED(rv))
chan.forget(result);
}
} }
return rv; }
channel->SetLoadInfo(aLoadInfo);
channel.forget(outChannel);
return NS_OK;
}
inline nsresult
NS_NewChannelInternal(nsIChannel** outChannel,
nsIURI* aUri,
nsINode* aRequestingNode,
nsIPrincipal* aRequestingPrincipal,
nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType,
nsIChannelPolicy* aChannelPolicy = nullptr,
nsILoadGroup* aLoadGroup = nullptr,
nsIInterfaceRequestor* aCallbacks = nullptr,
nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL,
nsIIOService* aIoService = nullptr)
{
NS_ASSERTION(aRequestingPrincipal, "Can not create channel without a requesting Principal!");
nsCOMPtr<nsILoadInfo> loadInfo =
new mozilla::LoadInfo(aRequestingPrincipal,
aRequestingNode,
aSecurityFlags,
aContentPolicyType);
if (!loadInfo) {
return NS_ERROR_UNEXPECTED;
}
return NS_NewChannelInternal(outChannel,
aUri,
loadInfo,
aChannelPolicy,
aLoadGroup,
aCallbacks,
aLoadFlags,
aIoService);
}
inline nsresult /* NS_NewChannelNode */
NS_NewChannel(nsIChannel** outChannel,
nsIURI* aUri,
nsINode* aRequestingNode,
nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType,
nsIChannelPolicy* aChannelPolicy = nullptr,
nsILoadGroup* aLoadGroup = nullptr,
nsIInterfaceRequestor* aCallbacks = nullptr,
nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL,
nsIIOService* aIoService = nullptr)
{
NS_ASSERTION(aRequestingNode, "Can not create channel without a requesting Node!");
return NS_NewChannelInternal(outChannel,
aUri,
aRequestingNode,
aRequestingNode->NodePrincipal(),
aSecurityFlags,
aContentPolicyType,
aChannelPolicy,
aLoadGroup,
aCallbacks,
aLoadFlags,
aIoService);
}
inline nsresult /* NS_NewChannelPrincipal */
NS_NewChannel(nsIChannel** outChannel,
nsIURI* aUri,
nsIPrincipal* aRequestingPrincipal,
nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType,
nsIChannelPolicy* aChannelPolicy = nullptr,
nsILoadGroup* aLoadGroup = nullptr,
nsIInterfaceRequestor* aCallbacks = nullptr,
nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL,
nsIIOService* aIoService = nullptr)
{
return NS_NewChannelInternal(outChannel,
aUri,
nullptr, // aRequestingNode,
aRequestingPrincipal,
aSecurityFlags,
aContentPolicyType,
aChannelPolicy,
aLoadGroup,
aCallbacks,
aLoadFlags,
aIoService);
} }
// Use this function with CAUTION. It creates a stream that blocks when you // Use this function with CAUTION. It creates a stream that blocks when you
@ -241,48 +339,149 @@ NS_NewChannel(nsIChannel **result,
// to implement a full blown asynchronous consumer (via nsIStreamListener) look // to implement a full blown asynchronous consumer (via nsIStreamListener) look
// at nsIStreamLoader instead. // at nsIStreamLoader instead.
inline nsresult inline nsresult
NS_OpenURI(nsIInputStream **result, NS_OpenURIInternal(nsIInputStream** outStream,
nsIURI *uri, nsIURI* aUri,
nsIIOService *ioService = nullptr, // pass in nsIIOService to optimize callers nsINode* aRequestingNode,
nsILoadGroup *loadGroup = nullptr, nsIPrincipal* aRequestingPrincipal,
nsIInterfaceRequestor *callbacks = nullptr, nsSecurityFlags aSecurityFlags,
uint32_t loadFlags = nsIRequest::LOAD_NORMAL, nsContentPolicyType aContentPolicyType,
nsIChannel **channelOut = nullptr) nsILoadGroup* aLoadGroup = nullptr,
nsIInterfaceRequestor* aCallbacks = nullptr,
nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL,
nsIIOService* aIoService = nullptr, // pass in nsIIOService to optimize callers
nsIChannel** outChannel = nullptr)
{ {
nsresult rv; NS_ASSERTION(aRequestingPrincipal, "Can not create channel without a requesting Principal!");
nsCOMPtr<nsIChannel> channel;
rv = NS_NewChannel(getter_AddRefs(channel), uri, ioService, nsCOMPtr<nsIChannel> channel;
loadGroup, callbacks, loadFlags); nsresult rv = NS_NewChannelInternal(getter_AddRefs(channel),
if (NS_SUCCEEDED(rv)) { aUri,
nsIInputStream *stream; aRequestingNode,
rv = channel->Open(&stream); aRequestingPrincipal,
if (NS_SUCCEEDED(rv)) { aSecurityFlags,
*result = stream; aContentPolicyType,
if (channelOut) { nullptr, // aChannelPolicy,
*channelOut = nullptr; aLoadGroup,
channel.swap(*channelOut); aCallbacks,
} aLoadFlags,
} aIoService);
}
return rv; NS_ENSURE_SUCCESS(rv, rv);
nsIInputStream *stream;
rv = channel->Open(&stream);
NS_ENSURE_SUCCESS(rv, rv);
*outStream = stream;
if (outChannel) {
*outChannel = nullptr;
channel.swap(*outChannel);
}
return NS_OK;
}
inline nsresult /* NS_OpenURIprincipal */
NS_OpenURI(nsIInputStream** outStream,
nsIURI* aUri,
nsIPrincipal* aRequestingPrincipal,
nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType,
nsILoadGroup* aLoadGroup = nullptr,
nsIInterfaceRequestor* aCallbacks = nullptr,
nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL,
nsIIOService* aIoService = nullptr,
nsIChannel** outChannel = nullptr)
{
return NS_OpenURIInternal(outStream,
aUri,
nullptr, // aRequestingNode
aRequestingPrincipal,
aSecurityFlags,
aContentPolicyType,
aLoadGroup,
aCallbacks,
aLoadFlags,
aIoService,
outChannel);
} }
inline nsresult inline nsresult
NS_OpenURI(nsIStreamListener *listener, NS_OpenURIInternal(nsIStreamListener* aListener,
nsISupports *context, nsISupports* aContext,
nsIURI *uri, nsIURI* aUri,
nsIIOService *ioService = nullptr, // pass in nsIIOService to optimize callers nsILoadInfo* aLoadInfo,
nsILoadGroup *loadGroup = nullptr, nsILoadGroup* aLoadGroup = nullptr,
nsIInterfaceRequestor *callbacks = nullptr, nsIInterfaceRequestor* aCallbacks = nullptr,
uint32_t loadFlags = nsIRequest::LOAD_NORMAL) nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL,
nsIIOService* aIoService = nullptr)
{ {
nsresult rv; nsCOMPtr<nsIChannel> channel;
nsCOMPtr<nsIChannel> channel; nsresult rv = NS_NewChannelInternal(getter_AddRefs(channel),
rv = NS_NewChannel(getter_AddRefs(channel), uri, ioService, aUri,
loadGroup, callbacks, loadFlags); aLoadInfo,
if (NS_SUCCEEDED(rv)) nullptr, // aChannelPolicy
rv = channel->AsyncOpen(listener, context); aLoadGroup,
return rv; aCallbacks,
aLoadFlags,
aIoService);
NS_ENSURE_SUCCESS(rv, rv);
return channel->AsyncOpen(aListener, aContext);
}
inline nsresult
NS_OpenURIInternal(nsIStreamListener* aListener,
nsISupports* aContext,
nsIURI* aUri,
nsINode* aRequestingNode,
nsIPrincipal* aRequestingPrincipal,
nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType,
nsILoadGroup* aLoadGroup = nullptr,
nsIInterfaceRequestor* aCallbacks = nullptr,
nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL,
nsIIOService* aIoService = nullptr)
{
NS_ASSERTION(aRequestingPrincipal, "Can not create channel without a requesting Principal!");
nsCOMPtr<nsILoadInfo> loadInfo =
new mozilla::LoadInfo(aRequestingPrincipal,
aRequestingNode,
aSecurityFlags,
aContentPolicyType);
if (!loadInfo) {
return NS_ERROR_UNEXPECTED;
}
return NS_OpenURIInternal(aListener,
aContext,
aUri,
loadInfo,
aLoadGroup,
aCallbacks,
aLoadFlags,
aIoService);
}
inline nsresult
NS_OpenURI(nsIStreamListener* aListener,
nsISupports* aContext,
nsIURI* aUri,
nsIPrincipal* aRequestingPrincipal,
nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType,
nsILoadGroup* aLoadGroup = nullptr,
nsIInterfaceRequestor* aCallbacks = nullptr,
nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL,
nsIIOService* aIoService = nullptr)
{
return NS_OpenURIInternal(aListener,
aContext,
aUri,
nullptr, // aRequestingNode
aRequestingPrincipal,
aSecurityFlags,
aContentPolicyType,
aLoadGroup,
aCallbacks,
aLoadFlags,
aIoService);
} }
inline nsresult inline nsresult
@ -609,32 +808,95 @@ NS_NewStreamLoader(nsIStreamLoader **result,
} }
inline nsresult inline nsresult
NS_NewStreamLoader(nsIStreamLoader **result, NS_NewStreamLoaderInternal(nsIStreamLoader** outStream,
nsIURI *uri, nsIURI* aUri,
nsIStreamLoaderObserver *observer, nsIStreamLoaderObserver* aObserver,
nsISupports *context = nullptr, nsINode* aRequestingNode,
nsILoadGroup *loadGroup = nullptr, nsIPrincipal* aRequestingPrincipal,
nsIInterfaceRequestor *callbacks = nullptr, nsSecurityFlags aSecurityFlags,
uint32_t loadFlags = nsIRequest::LOAD_NORMAL, nsContentPolicyType aContentPolicyType,
nsIURI *referrer = nullptr) nsISupports* aContext = nullptr,
nsILoadGroup* aLoadGroup = nullptr,
nsIInterfaceRequestor* aCallbacks = nullptr,
nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL,
nsIURI* aReferrer = nullptr)
{ {
nsresult rv; nsCOMPtr<nsIChannel> channel;
nsCOMPtr<nsIChannel> channel; nsresult rv = NS_NewChannelInternal(getter_AddRefs(channel),
rv = NS_NewChannel(getter_AddRefs(channel), aUri,
uri, aRequestingNode,
nullptr, aRequestingPrincipal,
loadGroup, aSecurityFlags,
callbacks, aContentPolicyType,
loadFlags); nullptr, // aChannelPolicy
if (NS_SUCCEEDED(rv)) { aLoadGroup,
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel)); aCallbacks,
if (httpChannel) aLoadFlags);
httpChannel->SetReferrer(referrer);
rv = NS_NewStreamLoader(result, observer); NS_ENSURE_SUCCESS(rv, rv);
if (NS_SUCCEEDED(rv)) nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
rv = channel->AsyncOpen(*result, context); if (httpChannel) {
} httpChannel->SetReferrer(aReferrer);
return rv; }
rv = NS_NewStreamLoader(outStream, aObserver);
NS_ENSURE_SUCCESS(rv, rv);
return channel->AsyncOpen(*outStream, aContext);
}
inline nsresult /* NS_NewStreamLoaderNode */
NS_NewStreamLoader(nsIStreamLoader** outStream,
nsIURI* aUri,
nsIStreamLoaderObserver* aObserver,
nsINode* aRequestingNode,
nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType,
nsISupports* aContext = nullptr,
nsILoadGroup* aLoadGroup = nullptr,
nsIInterfaceRequestor* aCallbacks = nullptr,
nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL,
nsIURI* aReferrer = nullptr)
{
NS_ASSERTION(aRequestingNode, "Can not create stream loader without a requesting Node!");
return NS_NewStreamLoaderInternal(outStream,
aUri,
aObserver,
aRequestingNode,
aRequestingNode->NodePrincipal(),
aSecurityFlags,
aContentPolicyType,
aContext,
aLoadGroup,
aCallbacks,
aLoadFlags,
aReferrer);
}
inline nsresult /* NS_NewStreamLoaderPrincipal */
NS_NewStreamLoader(nsIStreamLoader** outStream,
nsIURI* aUri,
nsIStreamLoaderObserver* aObserver,
nsIPrincipal* aRequestingPrincipal,
nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType,
nsISupports* aContext = nullptr,
nsILoadGroup* aLoadGroup = nullptr,
nsIInterfaceRequestor* aCallbacks = nullptr,
nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL,
nsIURI* aReferrer = nullptr)
{
return NS_NewStreamLoaderInternal(outStream,
aUri,
aObserver,
nullptr, // aRequestingNode
aRequestingPrincipal,
aSecurityFlags,
aContentPolicyType,
aContext,
aLoadGroup,
aCallbacks,
aLoadFlags,
aReferrer);
} }
inline nsresult inline nsresult
@ -1241,41 +1503,57 @@ NS_ReadInputStreamToString(nsIInputStream *aInputStream,
#endif #endif
inline nsresult inline nsresult
NS_LoadPersistentPropertiesFromURI(nsIPersistentProperties **result, NS_LoadPersistentPropertiesFromURI(nsIPersistentProperties** outResult,
nsIURI *uri, nsIURI* aUri,
nsIIOService *ioService = nullptr) nsIPrincipal* aRequestingPrincipal,
nsContentPolicyType aContentPolicyType,
nsIIOService* aIoService = nullptr)
{ {
nsCOMPtr<nsIInputStream> in; nsCOMPtr<nsIInputStream> in;
nsresult rv = NS_OpenURI(getter_AddRefs(in), uri, ioService); nsresult rv = NS_OpenURI(getter_AddRefs(in),
aUri,
aRequestingPrincipal,
nsILoadInfo::SEC_NORMAL,
aContentPolicyType,
nullptr, // aLoadGroup
nullptr, // aCallbacks
nsIRequest::LOAD_NORMAL, //aLoadFlags
aIoService);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIPersistentProperties> properties =
do_CreateInstance(NS_PERSISTENTPROPERTIES_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = properties->Load(in);
if (NS_SUCCEEDED(rv)) { if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIPersistentProperties> properties = *outResult = nullptr;
do_CreateInstance(NS_PERSISTENTPROPERTIES_CONTRACTID, &rv); properties.swap(*outResult);
if (NS_SUCCEEDED(rv)) {
rv = properties->Load(in);
if (NS_SUCCEEDED(rv)) {
*result = nullptr;
properties.swap(*result);
}
}
} }
return rv; return rv;
} }
inline nsresult inline nsresult
NS_LoadPersistentPropertiesFromURISpec(nsIPersistentProperties **result, NS_LoadPersistentPropertiesFromURISpec(nsIPersistentProperties** outResult,
const nsACString &spec, const nsACString& aSpec,
const char *charset = nullptr, nsIPrincipal* aRequestingPrincipal,
nsIURI *baseURI = nullptr, nsContentPolicyType aContentPolicyType,
nsIIOService *ioService = nullptr) const char* aCharset = nullptr,
nsIURI* aBaseURI = nullptr,
nsIIOService* aIoService = nullptr)
{ {
nsCOMPtr<nsIURI> uri; nsCOMPtr<nsIURI> uri;
nsresult rv = nsresult rv = NS_NewURI(getter_AddRefs(uri),
NS_NewURI(getter_AddRefs(uri), spec, charset, baseURI, ioService); aSpec,
aCharset,
aBaseURI,
aIoService);
NS_ENSURE_SUCCESS(rv, rv);
if (NS_SUCCEEDED(rv)) return NS_LoadPersistentPropertiesFromURI(outResult,
rv = NS_LoadPersistentPropertiesFromURI(result, uri, ioService); uri,
aRequestingPrincipal,
return rv; aContentPolicyType,
aIoService);
} }
/** /**