--- a/browser/base/content/test/static/browser_parsable_css.js
+++ b/browser/base/content/test/static/browser_parsable_css.js
@@ -302,17 +302,17 @@ function processCSSRules(sheet) {
}
}
}
function chromeFileExists(aURI) {
let available = 0;
try {
let channel = NetUtil.newChannel({uri: aURI, loadUsingSystemPrincipal: true});
- let stream = channel.open();
+ let stream = channel.open2();
let sstream = Cc["@mozilla.org/scriptableinputstream;1"]
.createInstance(Ci.nsIScriptableInputStream);
sstream.init(stream);
available = sstream.available();
sstream.close();
} catch (e) {
if (e.result != Cr.NS_ERROR_FILE_NOT_FOUND) {
dump("Checking " + aURI + ": " + e + "\n");
--- a/dom/base/test/chrome/test_bug682305.html
+++ b/dom/base/test/chrome/test_bug682305.html
@@ -48,32 +48,29 @@ CustomChannel.prototype = {
contentType: "text/plain",
owner: Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal),
securityInfo: null,
notificationCallbacks: null,
loadFlags: 0,
loadGroup: null,
name: null,
status: Cr.NS_OK,
- asyncOpen: function(listener, context) {
- let stream = this.open();
- try {
- listener.onStartRequest(this, context);
- } catch(e) {}
- try {
- listener.onDataAvailable(this, context, stream, 0, stream.available());
- } catch(e) {}
- try {
- listener.onStopRequest(this, context, Cr.NS_OK);
- } catch(e) {}
- },
asyncOpen2: function(listener) {
// throws an error if security checks fail
var outListener = contentSecManager.performSecurityCheck(this, listener);
- return this.asyncOpen(outListener, null);
+ let stream = this.open();
+ try {
+ outListener.onStartRequest(this, null);
+ } catch(e) {}
+ try {
+ outListener.onDataAvailable(this, null, stream, 0, stream.available());
+ } catch(e) {}
+ try {
+ outListener.onStopRequest(this, null, Cr.NS_OK);
+ } catch(e) {}
},
open: function() {
let data = "bar";
let stream = Cc["@mozilla.org/io/string-input-stream;1"].createInstance(Ci.nsIStringInputStream);
stream.setData(data, data.length);
return stream;
},
open2: function() {
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -3211,19 +3211,17 @@ public:
NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor*) NO_IMPL
NS_IMETHOD GetSecurityInfo(nsISupports**) NO_IMPL
NS_IMETHOD GetContentType(nsACString&) NO_IMPL
NS_IMETHOD SetContentType(const nsACString&) NO_IMPL
NS_IMETHOD GetContentCharset(nsACString&) NO_IMPL
NS_IMETHOD SetContentCharset(const nsACString&) NO_IMPL
NS_IMETHOD GetContentLength(int64_t*) NO_IMPL
NS_IMETHOD SetContentLength(int64_t) NO_IMPL
- NS_IMETHOD Open(nsIInputStream**) NO_IMPL
NS_IMETHOD Open2(nsIInputStream**) NO_IMPL
- NS_IMETHOD AsyncOpen(nsIStreamListener*, nsISupports*) NO_IMPL
NS_IMETHOD AsyncOpen2(nsIStreamListener*) NO_IMPL
NS_IMETHOD GetContentDisposition(uint32_t*) NO_IMPL
NS_IMETHOD SetContentDisposition(uint32_t) NO_IMPL
NS_IMETHOD GetContentDispositionFilename(nsAString&) NO_IMPL
NS_IMETHOD SetContentDispositionFilename(const nsAString&) NO_IMPL
NS_IMETHOD GetContentDispositionHeader(nsACString&) NO_IMPL
NS_IMETHOD OnAuthAvailable(nsISupports *aContext, nsIAuthInformation *aAuthInfo) override;
NS_IMETHOD OnAuthCancelled(nsISupports *aContext, bool userCancel) override;
--- a/dom/jsurl/nsJSProtocolHandler.cpp
+++ b/dom/jsurl/nsJSProtocolHandler.cpp
@@ -520,49 +520,45 @@ nsJSChannel::SetOriginalURI(nsIURI *aURI
NS_IMETHODIMP
nsJSChannel::GetURI(nsIURI * *aURI)
{
return mStreamChannel->GetURI(aURI);
}
NS_IMETHODIMP
-nsJSChannel::Open(nsIInputStream **aResult)
-{
- nsresult rv = mIOThunk->EvaluateScript(mStreamChannel, mPopupState,
- mExecutionPolicy,
- mOriginalInnerWindow);
- NS_ENSURE_SUCCESS(rv, rv);
-
- return mStreamChannel->Open(aResult);
-}
-
-NS_IMETHODIMP
nsJSChannel::Open2(nsIInputStream** aStream)
{
nsCOMPtr<nsIStreamListener> listener;
nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
NS_ENSURE_SUCCESS(rv, rv);
- return Open(aStream);
+
+ rv = mIOThunk->EvaluateScript(mStreamChannel, mPopupState,
+ mExecutionPolicy,
+ mOriginalInnerWindow);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return mStreamChannel->Open2(aStream);
}
NS_IMETHODIMP
-nsJSChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext)
+nsJSChannel::AsyncOpen2(nsIStreamListener *aListener)
{
+ nsCOMPtr<nsIStreamListener> listener = aListener;
+ nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+ NS_ENSURE_SUCCESS(rv, rv);
#ifdef DEBUG
{
nsCOMPtr<nsILoadInfo> loadInfo = nsIChannel::GetLoadInfo();
MOZ_ASSERT(!loadInfo || loadInfo->GetSecurityMode() == 0 ||
loadInfo->GetInitialSecurityCheckDone(),
"security flags in loadInfo but asyncOpen2() not called");
}
#endif
- MOZ_RELEASE_ASSERT(!aContext, "please call AsyncOpen2()");
-
- NS_ENSURE_ARG(aListener);
+ NS_ENSURE_ARG(listener);
// First make sure that we have a usable inner window; we'll want to make
// sure that we execute against that inner and no other.
nsIScriptGlobalObject* global = GetGlobalObject(this);
if (!global) {
return NS_ERROR_NOT_AVAILABLE;
}
@@ -571,17 +567,17 @@ nsJSChannel::AsyncOpen(nsIStreamListener
// Make sure we create a new inner window if one doesn't already exist (see
// bug 306630).
mOriginalInnerWindow = win->EnsureInnerWindow();
if (!mOriginalInnerWindow) {
return NS_ERROR_NOT_AVAILABLE;
}
- mListener = aListener;
+ mListener = listener;
mIsActive = true;
// Temporarily set the LOAD_BACKGROUND flag to suppress load group observer
// notifications (and hence nsIWebProgressListener notifications) from
// being dispatched. This is required since we suppress LOAD_DOCUMENT_URI,
// which means that the DocLoader would not generate document start and
// stop notifications (see bug 257875).
@@ -653,35 +649,26 @@ nsJSChannel::AsyncOpen(nsIStreamListener
// stream channel. We'll have to notify ourselves, but make sure to do
// it asynchronously.
method = &nsJSChannel::NotifyListener;
name = "nsJSChannel::NotifyListener";
}
nsCOMPtr<nsIRunnable> runnable = mozilla::NewRunnableMethod(name, this, method);
nsGlobalWindowInner* window = nsGlobalWindowInner::Cast(mOriginalInnerWindow);
- nsresult rv = window->Dispatch(mozilla::TaskCategory::Other, runnable.forget());
+ rv = window->Dispatch(mozilla::TaskCategory::Other, runnable.forget());
if (NS_FAILED(rv)) {
loadGroup->RemoveRequest(this, nullptr, rv);
mIsActive = false;
CleanupStrongRefs();
}
return rv;
}
-NS_IMETHODIMP
-nsJSChannel::AsyncOpen2(nsIStreamListener *aListener)
-{
- nsCOMPtr<nsIStreamListener> listener = aListener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- NS_ENSURE_SUCCESS(rv, rv);
- return AsyncOpen(listener, nullptr);
-}
-
void
nsJSChannel::EvaluateScript()
{
// Synchronously execute the script...
// mIsActive is used to indicate the the request is 'busy' during the
// the script evaluation phase. This means that IsPending() will
// indicate the the request is busy while the script is executing...
--- a/image/decoders/icon/mac/nsIconChannelCocoa.mm
+++ b/image/decoders/icon/mac/nsIconChannelCocoa.mm
@@ -166,28 +166,22 @@ NS_IMETHODIMP
nsIconChannel::GetURI(nsIURI** aURI)
{
*aURI = mUrl;
NS_IF_ADDREF(*aURI);
return NS_OK;
}
NS_IMETHODIMP
-nsIconChannel::Open(nsIInputStream** _retval)
-{
- return MakeInputStream(_retval, false);
-}
-
-NS_IMETHODIMP
nsIconChannel::Open2(nsIInputStream** aStream)
{
nsCOMPtr<nsIStreamListener> listener;
nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
NS_ENSURE_SUCCESS(rv, rv);
- return Open(aStream);
+ return MakeInputStream(aStream, false);
}
nsresult
nsIconChannel::ExtractIconInfoFromUrl(nsIFile** aLocalFile,
uint32_t* aDesiredImageSize,
nsACString& aContentType,
nsACString& aFileExtension)
{
@@ -215,70 +209,63 @@ nsIconChannel::ExtractIconInfoFromUrl(ns
*aLocalFile = file;
NS_IF_ADDREF(*aLocalFile);
return NS_OK;
}
NS_IMETHODIMP
-nsIconChannel::AsyncOpen(nsIStreamListener* aListener,
- nsISupports* ctxt)
+nsIconChannel::AsyncOpen2(nsIStreamListener* aListener)
{
+ nsCOMPtr<nsIStreamListener> listener = aListener;
+ nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+ if (NS_FAILED(rv)) {
+ mCallbacks = nullptr;
+ return rv;
+ }
MOZ_ASSERT(!mLoadInfo ||
mLoadInfo->GetSecurityMode() == 0 ||
mLoadInfo->GetInitialSecurityCheckDone() ||
(mLoadInfo->GetSecurityMode() == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL &&
nsContentUtils::IsSystemPrincipal(mLoadInfo->LoadingPrincipal())),
"security flags in loadInfo but asyncOpen2() not called");
nsCOMPtr<nsIInputStream> inStream;
- nsresult rv = MakeInputStream(getter_AddRefs(inStream), true);
+ rv = MakeInputStream(getter_AddRefs(inStream), true);
if (NS_FAILED(rv)) {
mCallbacks = nullptr;
return rv;
}
// Init our stream pump
nsCOMPtr<nsIEventTarget> target =
nsContentUtils::GetEventTargetByLoadInfo(mLoadInfo,
mozilla::TaskCategory::Other);
rv = mPump->Init(inStream, 0, 0, false, target);
if (NS_FAILED(rv)) {
mCallbacks = nullptr;
return rv;
}
- rv = mPump->AsyncRead(this, ctxt);
+ rv = mPump->AsyncRead(this, nullptr);
if (NS_SUCCEEDED(rv)) {
// Store our real listener
- mListener = aListener;
+ mListener = listener;
// Add ourself to the load group, if available
if (mLoadGroup) {
mLoadGroup->AddRequest(this, nullptr);
}
} else {
mCallbacks = nullptr;
}
return rv;
}
-NS_IMETHODIMP
-nsIconChannel::AsyncOpen2(nsIStreamListener* aListener)
-{
- nsCOMPtr<nsIStreamListener> listener = aListener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- if (NS_FAILED(rv)) {
- mCallbacks = nullptr;
- return rv;
- }
- return AsyncOpen(listener, nullptr);
-}
-
nsresult
nsIconChannel::MakeInputStream(nsIInputStream** _retval,
bool aNonBlocking)
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
nsCString contentType;
nsAutoCString fileExt;
--- a/image/decoders/icon/win/nsIconChannel.cpp
+++ b/image/decoders/icon/win/nsIconChannel.cpp
@@ -188,28 +188,22 @@ NS_IMETHODIMP
nsIconChannel::GetURI(nsIURI** aURI)
{
*aURI = mUrl;
NS_IF_ADDREF(*aURI);
return NS_OK;
}
NS_IMETHODIMP
-nsIconChannel::Open(nsIInputStream** _retval)
-{
- return MakeInputStream(_retval, false);
-}
-
-NS_IMETHODIMP
nsIconChannel::Open2(nsIInputStream** aStream)
{
nsCOMPtr<nsIStreamListener> listener;
nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
NS_ENSURE_SUCCESS(rv, rv);
- return Open(aStream);
+ return MakeInputStream(aStream, false);
}
nsresult
nsIconChannel::ExtractIconInfoFromUrl(nsIFile** aLocalFile,
uint32_t* aDesiredImageSize, nsCString& aContentType,
nsCString& aFileExtension)
{
nsresult rv = NS_OK;
@@ -230,70 +224,64 @@ nsIconChannel::ExtractIconInfoFromUrl(ns
nsCOMPtr<nsIFile> file;
rv = fileURL->GetFile(getter_AddRefs(file));
if (NS_FAILED(rv) || !file) return NS_OK;
return file->Clone(aLocalFile);
}
NS_IMETHODIMP
-nsIconChannel::AsyncOpen(nsIStreamListener* aListener,
- nsISupports* ctxt)
+nsIconChannel::AsyncOpen2(nsIStreamListener* aListener)
{
+ nsCOMPtr<nsIStreamListener> listener = aListener;
+ nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+ if (NS_FAILED(rv)) {
+ mCallbacks = nullptr;
+ return rv;
+ }
+
MOZ_ASSERT(!mLoadInfo ||
mLoadInfo->GetSecurityMode() == 0 ||
mLoadInfo->GetInitialSecurityCheckDone() ||
(mLoadInfo->GetSecurityMode() == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL &&
nsContentUtils::IsSystemPrincipal(mLoadInfo->LoadingPrincipal())),
"security flags in loadInfo but asyncOpen2() not called");
nsCOMPtr<nsIInputStream> inStream;
- nsresult rv = MakeInputStream(getter_AddRefs(inStream), true);
+ rv = MakeInputStream(getter_AddRefs(inStream), true);
if (NS_FAILED(rv)) {
mCallbacks = nullptr;
return rv;
}
// Init our streampump
nsCOMPtr<nsIEventTarget> target =
nsContentUtils::GetEventTargetByLoadInfo(mLoadInfo,
mozilla::TaskCategory::Other);
rv = mPump->Init(inStream, 0, 0, false, target);
if (NS_FAILED(rv)) {
mCallbacks = nullptr;
return rv;
}
- rv = mPump->AsyncRead(this, ctxt);
+ rv = mPump->AsyncRead(this, nullptr);
if (NS_SUCCEEDED(rv)) {
// Store our real listener
- mListener = aListener;
+ mListener = listener;
// Add ourself to the load group, if available
if (mLoadGroup) {
mLoadGroup->AddRequest(this, nullptr);
}
} else {
mCallbacks = nullptr;
}
return rv;
}
-NS_IMETHODIMP
-nsIconChannel::AsyncOpen2(nsIStreamListener* aListener)
-{
- nsCOMPtr<nsIStreamListener> listener = aListener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- if (NS_FAILED(rv)) {
- mCallbacks = nullptr;
- return rv;
- }
- return AsyncOpen(listener, nullptr);
-}
-
static DWORD
GetSpecialFolderIcon(nsIFile* aFile, int aFolder,
SHFILEINFOW* aSFI, UINT aInfoFlags)
{
DWORD shellResult = 0;
if (!aFile) {
return shellResult;
--- a/modules/libjar/nsJARChannel.cpp
+++ b/modules/libjar/nsJARChannel.cpp
@@ -580,17 +580,16 @@ nsJARChannel::OnOpenLocalFileComplete(ns
}
if (mLoadGroup) {
mLoadGroup->RemoveRequest(this, nullptr, aResult);
}
mOpened = false;
mIsPending = false;
- mListenerContext = nullptr;
mListener = nullptr;
mCallbacks = nullptr;
mProgressSink = nullptr;
return aResult;
}
return NS_OK;
@@ -945,61 +944,65 @@ NS_IMETHODIMP
nsJARChannel::SetContentLength(int64_t aContentLength)
{
// XXX does this really make any sense at all?
mContentLength = aContentLength;
return NS_OK;
}
NS_IMETHODIMP
-nsJARChannel::Open(nsIInputStream **stream)
+nsJARChannel::Open2(nsIInputStream** aStream)
{
+ nsCOMPtr<nsIStreamListener> listener;
+ nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+ NS_ENSURE_SUCCESS(rv, rv);
+
LOG(("nsJARChannel::Open [this=%p]\n", this));
NS_ENSURE_TRUE(!mOpened, NS_ERROR_IN_PROGRESS);
NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);
mJarFile = nullptr;
mIsUnsafe = true;
- nsresult rv = LookupFile();
+ rv = LookupFile();
if (NS_FAILED(rv))
return rv;
// If mJarInput was not set by LookupFile, the JAR is a remote jar.
if (!mJarFile) {
NS_NOTREACHED("need sync downloader");
return NS_ERROR_NOT_IMPLEMENTED;
}
RefPtr<nsJARInputThunk> input;
rv = CreateJarInput(gJarHandler->JarCache(), getter_AddRefs(input));
if (NS_FAILED(rv))
return rv;
- input.forget(stream);
+ input.forget(aStream);
mOpened = true;
// local files are always considered safe
mIsUnsafe = false;
return NS_OK;
}
NS_IMETHODIMP
-nsJARChannel::Open2(nsIInputStream** aStream)
+nsJARChannel::AsyncOpen2(nsIStreamListener *aListener)
{
- LOG(("nsJARChannel::Open2 [this=%p]\n", this));
- nsCOMPtr<nsIStreamListener> listener;
+ nsCOMPtr<nsIStreamListener> listener = aListener;
nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- NS_ENSURE_SUCCESS(rv, rv);
- return Open(aStream);
-}
+ if (NS_FAILED(rv)) {
+ mIsPending = false;
+ mListener = nullptr;
+ mCallbacks = nullptr;
+ mProgressSink = nullptr;
+ return rv;
+ }
-NS_IMETHODIMP
-nsJARChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctx)
-{
LOG(("nsJARChannel::AsyncOpen [this=%p]\n", this));
MOZ_ASSERT(!mLoadInfo ||
mLoadInfo->GetSecurityMode() == 0 ||
mLoadInfo->GetInitialSecurityCheckDone() ||
(mLoadInfo->GetSecurityMode() == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL &&
nsContentUtils::IsSystemPrincipal(mLoadInfo->LoadingPrincipal())),
"security flags in loadInfo but asyncOpen2() not called");
@@ -1011,39 +1014,36 @@ nsJARChannel::AsyncOpen(nsIStreamListene
mJarFile = nullptr;
mIsUnsafe = true;
// Initialize mProgressSink
NS_QueryNotificationCallbacks(mCallbacks, mLoadGroup, mProgressSink);
mListener = listener;
- mListenerContext = ctx;
mIsPending = true;
- nsresult rv = LookupFile();
+ rv = LookupFile();
if (NS_FAILED(rv)) {
mIsPending = false;
- mListenerContext = nullptr;
mListener = nullptr;
mCallbacks = nullptr;
mProgressSink = nullptr;
return rv;
}
nsCOMPtr<nsIChannel> channel;
if (!mJarFile) {
// Not a local file...
// Check preferences to see if all remote jar support should be disabled
if (mBlockRemoteFiles) {
mIsUnsafe = true;
mIsPending = false;
- mListenerContext = nullptr;
mListener = nullptr;
mCallbacks = nullptr;
mProgressSink = nullptr;
return NS_ERROR_UNSAFE_CONTENT_TYPE;
}
// kick off an async download of the base URI...
nsCOMPtr<nsIStreamListener> downloader = new MemoryDownloader(this);
@@ -1053,72 +1053,47 @@ nsJARChannel::AsyncOpen(nsIStreamListene
mJarBaseURI,
mLoadInfo,
nullptr, // PerformanceStorage
mLoadGroup,
mCallbacks,
loadFlags);
if (NS_FAILED(rv)) {
mIsPending = false;
- mListenerContext = nullptr;
mListener = nullptr;
mCallbacks = nullptr;
mProgressSink = nullptr;
return rv;
}
- if (mLoadInfo && mLoadInfo->GetEnforceSecurity()) {
- rv = channel->AsyncOpen2(downloader);
- }
- else {
- rv = channel->AsyncOpen(downloader, nullptr);
- }
-
+ MOZ_ASSERT(mLoadInfo && mLoadInfo->GetEnforceSecurity());
+ rv = channel->AsyncOpen2(downloader);
}
else {
rv = OpenLocalFile();
if (NS_SUCCEEDED(rv)) {
return NS_OK;
}
}
if (NS_FAILED(rv)) {
mIsPending = false;
- mListenerContext = nullptr;
mListener = nullptr;
mCallbacks = nullptr;
mProgressSink = nullptr;
return rv;
}
if (mLoadGroup)
mLoadGroup->AddRequest(this, nullptr);
mOpened = true;
LOG(("nsJARChannel::AsyncOpen [this=%p] 8\n", this));
return NS_OK;
}
-NS_IMETHODIMP
-nsJARChannel::AsyncOpen2(nsIStreamListener *aListener)
-{
- LOG(("nsJARChannel::AsyncOpen2 [this=%p]\n", this));
- nsCOMPtr<nsIStreamListener> listener = aListener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- if (NS_FAILED(rv)) {
- mIsPending = false;
- mListenerContext = nullptr;
- mListener = nullptr;
- mCallbacks = nullptr;
- mProgressSink = nullptr;
- return rv;
- }
-
- return AsyncOpen(listener, nullptr);
-}
-
//-----------------------------------------------------------------------------
// nsIJARChannel
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsJARChannel::GetIsUnsafe(bool *isUnsafe)
{
*isUnsafe = mIsUnsafe;
return NS_OK;
@@ -1325,35 +1300,34 @@ nsJARChannel::OnDownloadComplete(MemoryD
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsJARChannel::OnStartRequest(nsIRequest *req, nsISupports *ctx)
{
LOG(("nsJARChannel::OnStartRequest [this=%p %s]\n", this, mSpec.get()));
mRequest = req;
- nsresult rv = mListener->OnStartRequest(this, mListenerContext);
+ nsresult rv = mListener->OnStartRequest(this, nullptr);
mRequest = nullptr;
return rv;
}
NS_IMETHODIMP
nsJARChannel::OnStopRequest(nsIRequest *req, nsISupports *ctx, nsresult status)
{
LOG(("nsJARChannel::OnStopRequest [this=%p %s status=%" PRIx32 "]\n",
this, mSpec.get(), static_cast<uint32_t>(status)));
if (NS_SUCCEEDED(mStatus))
mStatus = status;
if (mListener) {
- mListener->OnStopRequest(this, mListenerContext, status);
+ mListener->OnStopRequest(this, nullptr, status);
mListener = nullptr;
- mListenerContext = nullptr;
}
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nullptr, status);
mPump = nullptr;
mIsPending = false;
@@ -1374,17 +1348,17 @@ NS_IMETHODIMP
nsJARChannel::OnDataAvailable(nsIRequest *req, nsISupports *ctx,
nsIInputStream *stream,
uint64_t offset, uint32_t count)
{
LOG(("nsJARChannel::OnDataAvailable [this=%p %s]\n", this, mSpec.get()));
nsresult rv;
- rv = mListener->OnDataAvailable(this, mListenerContext, stream, offset, count);
+ rv = mListener->OnDataAvailable(this, nullptr, stream, offset, count);
// simply report progress here instead of hooking ourselves up as a
// nsITransportEventSink implementation.
// XXX do the 64-bit stuff for real
if (mProgressSink && NS_SUCCEEDED(rv)) {
if (NS_IsMainThread()) {
FireOnProgress(offset + count);
} else {
--- a/modules/libjar/nsJARChannel.h
+++ b/modules/libjar/nsJARChannel.h
@@ -82,17 +82,16 @@ private:
nsCOMPtr<nsIURI> mOriginalURI;
nsCOMPtr<nsISupports> mOwner;
nsCOMPtr<nsILoadInfo> mLoadInfo;
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsISupports> mSecurityInfo;
nsCOMPtr<nsIProgressEventSink> mProgressSink;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsIStreamListener> mListener;
- nsCOMPtr<nsISupports> mListenerContext;
nsCString mContentType;
nsCString mContentCharset;
nsCString mContentDispositionHeader;
/* mContentDisposition is uninitialized if mContentDispositionHeader is
* empty */
uint32_t mContentDisposition;
int64_t mContentLength;
uint32_t mLoadFlags;
--- a/netwerk/base/NetUtil.jsm
+++ b/netwerk/base/NetUtil.jsm
@@ -136,33 +136,29 @@ var NetUtil = {
return;
}
let channel = aSource;
if (!(channel instanceof Ci.nsIChannel)) {
channel = this.newChannel(aSource);
}
+ if (!channel.loadInfo ||
+ channel.loadInfo.securityMode == 0) {
+ throw new Components.Exception(
+ "NetUtil.jsm: asyncFetch() requires the channel to have " +
+ "one of the security flags set in the loadinfo (see nsILoadInfo). " +
+ "Please create channel using NetUtil.newChannel()",
+ Cr.NS_ERROR_INVALID_ARG,
+ Components.stack.caller
+ );
+ }
+
try {
- // Open the channel using asyncOpen2() if the loadinfo contains one
- // of the security mode flags, otherwise fall back to use asyncOpen().
- if (channel.loadInfo &&
- channel.loadInfo.securityMode != 0) {
- channel.asyncOpen2(listener);
- }
- else {
- // Log deprecation warning to console to make sure all channels
- // are created providing the correct security flags in the loadinfo.
- // See nsILoadInfo for all available security flags and also the API
- // of NetUtil.newChannel() for details above.
- Cu.reportError("NetUtil.jsm: asyncFetch() requires the channel to have " +
- "one of the security flags set in the loadinfo (see nsILoadInfo). " +
- "Please create channel using NetUtil.newChannel()");
- channel.asyncOpen(listener, null);
- }
+ channel.asyncOpen2(listener);
}
catch (e) {
let exception = new Components.Exception(
"Failed to open input source '" + channel.originalURI.spec + "'",
e.result,
Components.stack.caller,
aSource,
e
--- a/netwerk/base/SimpleChannel.cpp
+++ b/netwerk/base/SimpleChannel.cpp
@@ -127,22 +127,19 @@ NS_IMETHODIMP
SimpleChannelChild::CompleteRedirectSetup(nsIStreamListener* aListener,
nsISupports* aContext)
{
if (mIPDLRef) {
MOZ_ASSERT(NS_IsMainThread());
}
nsresult rv;
- if (mLoadInfo && mLoadInfo->GetEnforceSecurity()) {
- MOZ_ASSERT(!aContext, "aContext should be null!");
- rv = AsyncOpen2(aListener);
- } else {
- rv = AsyncOpen(aListener, aContext);
- }
+ MOZ_ASSERT(mLoadInfo && mLoadInfo->GetEnforceSecurity());
+ MOZ_ASSERT(!aContext, "aContext should be null!");
+ rv = AsyncOpen2(aListener);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
if (mIPDLRef) {
Unused << Send__delete__(this);
}
return NS_OK;
--- a/netwerk/base/moz.build
+++ b/netwerk/base/moz.build
@@ -218,17 +218,16 @@ UNIFIED_SOURCES += [
'nsNetAddr.cpp',
'nsNetUtil.cpp',
'nsPACMan.cpp',
'nsPreloadedStream.cpp',
'nsProtocolProxyService.cpp',
'nsProxyInfo.cpp',
'nsRedirectHistoryEntry.cpp',
'nsRequestObserverProxy.cpp',
- 'nsSecCheckWrapChannel.cpp',
'nsSerializationHelper.cpp',
'nsServerSocket.cpp',
'nsSimpleNestedURI.cpp',
'nsSimpleStreamListener.cpp',
'nsSimpleURI.cpp',
'nsSocketTransport2.cpp',
'nsSocketTransportService2.cpp',
'nsStandardURL.cpp',
--- a/netwerk/base/nsBaseChannel.cpp
+++ b/netwerk/base/nsBaseChannel.cpp
@@ -181,23 +181,18 @@ nsBaseChannel::ContinueRedirect()
mRedirectChannel->SetOriginalURI(OriginalURI());
// If we fail to open the new channel, then we want to leave this channel
// unaffected, so we defer tearing down our channel until we have succeeded
// with the redirect.
if (mOpenRedirectChannel) {
nsresult rv = NS_OK;
- if (mLoadInfo && mLoadInfo->GetEnforceSecurity()) {
- MOZ_ASSERT(!mListenerContext, "mListenerContext should be null!");
- rv = mRedirectChannel->AsyncOpen2(mListener);
- }
- else {
- rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);
- }
+ MOZ_ASSERT(mLoadInfo && mLoadInfo->GetEnforceSecurity());
+ rv = mRedirectChannel->AsyncOpen2(mListener);
NS_ENSURE_SUCCESS(rv, rv);
}
mRedirectChannel = nullptr;
// close down this channel
Cancel(NS_BINDING_REDIRECTED);
ChannelDone();
@@ -222,17 +217,17 @@ nsBaseChannel::PushStreamConverter(const
nsresult rv;
nsCOMPtr<nsIStreamConverterService> scs =
do_GetService(NS_STREAMCONVERTERSERVICE_CONTRACTID, &rv);
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIStreamListener> converter;
- rv = scs->AsyncConvertData(fromType, toType, mListener, mListenerContext,
+ rv = scs->AsyncConvertData(fromType, toType, mListener, nullptr,
getter_AddRefs(converter));
if (NS_SUCCEEDED(rv)) {
mListener = converter;
if (invalidatesContentLength)
mContentLength = -1;
if (result) {
*result = nullptr;
converter.swap(*result);
@@ -314,18 +309,18 @@ nsBaseChannel::ContinueHandleAsyncRedire
{
mWaitingOnAsyncRedirect = false;
if (NS_FAILED(result))
Cancel(result);
if (NS_FAILED(result) && mListener) {
// Notify our consumer ourselves
- mListener->OnStartRequest(this, mListenerContext);
- mListener->OnStopRequest(this, mListenerContext, mStatus);
+ mListener->OnStartRequest(this, nullptr);
+ mListener->OnStopRequest(this, nullptr, mStatus);
ChannelDone();
}
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nullptr, mStatus);
// Drop notification callbacks to prevent cycles.
mCallbacks = nullptr;
@@ -636,53 +631,55 @@ nsBaseChannel::GetContentLength(int64_t
NS_IMETHODIMP
nsBaseChannel::SetContentLength(int64_t aContentLength)
{
mContentLength = aContentLength;
return NS_OK;
}
NS_IMETHODIMP
-nsBaseChannel::Open(nsIInputStream **result)
+nsBaseChannel::Open2(nsIInputStream** aStream)
{
+ nsCOMPtr<nsIStreamListener> listener;
+ nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+ NS_ENSURE_SUCCESS(rv, rv);
+
NS_ENSURE_TRUE(mURI, NS_ERROR_NOT_INITIALIZED);
NS_ENSURE_TRUE(!mPumpingData, NS_ERROR_IN_PROGRESS);
NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_IN_PROGRESS);
nsCOMPtr<nsIChannel> chan;
- nsresult rv = OpenContentStream(false, result, getter_AddRefs(chan));
- NS_ASSERTION(!chan || !*result, "Got both a channel and a stream?");
+ rv = OpenContentStream(false, aStream, getter_AddRefs(chan));
+ NS_ASSERTION(!chan || !*aStream, "Got both a channel and a stream?");
if (NS_SUCCEEDED(rv) && chan) {
rv = Redirect(chan, nsIChannelEventSink::REDIRECT_INTERNAL, false);
if (NS_FAILED(rv))
return rv;
- rv = chan->Open(result);
+ rv = chan->Open2(aStream);
} else if (rv == NS_ERROR_NOT_IMPLEMENTED)
- return NS_ImplementChannelOpen(this, result);
+ return NS_ImplementChannelOpen(this, aStream);
if (NS_SUCCEEDED(rv)) {
mWasOpened = true;
ClassifyURI();
}
return rv;
}
NS_IMETHODIMP
-nsBaseChannel::Open2(nsIInputStream** aStream)
+nsBaseChannel::AsyncOpen2(nsIStreamListener *aListener)
{
- nsCOMPtr<nsIStreamListener> listener;
+ nsCOMPtr<nsIStreamListener> listener = aListener;
nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- NS_ENSURE_SUCCESS(rv, rv);
- return Open(aStream);
-}
+ if (NS_FAILED(rv)) {
+ mCallbacks = nullptr;
+ return rv;
+ }
-NS_IMETHODIMP
-nsBaseChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt)
-{
MOZ_ASSERT(!mLoadInfo ||
mLoadInfo->GetSecurityMode() == 0 ||
mLoadInfo->GetInitialSecurityCheckDone() ||
(mLoadInfo->GetSecurityMode() == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL &&
nsContentUtils::IsSystemPrincipal(mLoadInfo->LoadingPrincipal())),
"security flags in loadInfo but asyncOpen2() not called");
NS_ENSURE_TRUE(mURI, NS_ERROR_NOT_INITIALIZED);
@@ -695,29 +692,28 @@ nsBaseChannel::AsyncOpen(nsIStreamListen
// Skip checking for chrome:// sub-resources.
nsAutoCString scheme;
mURI->GetScheme(scheme);
if (!scheme.EqualsLiteral("file")) {
NS_CompareLoadInfoAndLoadContext(this);
}
// Ensure that this is an allowed port before proceeding.
- nsresult rv = NS_CheckPortSafety(mURI);
+ rv = NS_CheckPortSafety(mURI);
if (NS_FAILED(rv)) {
mCallbacks = nullptr;
return rv;
}
- // Store the listener and context early so that OpenContentStream and the
+ // Store the listener early so that OpenContentStream and the
// stream's AsyncWait method (called by AsyncRead) can have access to them
// via PushStreamConverter and the StreamListener methods. However, since
// this typically introduces a reference cycle between this and the listener,
// we need to be sure to break the reference if this method does not succeed.
mListener = listener;
- mListenerContext = ctxt;
// This method assigns mPump as a side-effect. We need to clear mPump if
// this method fails.
rv = BeginPumpingData();
if (NS_FAILED(rv)) {
mPump = nullptr;
mRequest = nullptr;
mPumpingData = false;
@@ -735,28 +731,16 @@ nsBaseChannel::AsyncOpen(nsIStreamListen
if (mLoadGroup)
mLoadGroup->AddRequest(this, nullptr);
ClassifyURI();
return NS_OK;
}
-NS_IMETHODIMP
-nsBaseChannel::AsyncOpen2(nsIStreamListener *aListener)
-{
- nsCOMPtr<nsIStreamListener> listener = aListener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- if (NS_FAILED(rv)) {
- mCallbacks = nullptr;
- return rv;
- }
- return AsyncOpen(listener, nullptr);
-}
-
//-----------------------------------------------------------------------------
// nsBaseChannel::nsITransportEventSink
NS_IMETHODIMP
nsBaseChannel::OnTransportStatus(nsITransport *transport, nsresult status,
int64_t progress, int64_t progressMax)
{
// In some cases, we may wish to suppress transport-layer status events.
@@ -777,22 +761,22 @@ nsBaseChannel::OnTransportStatus(nsITran
if (!mProgressSink) {
return NS_OK;
}
}
if (!HasLoadFlag(LOAD_BACKGROUND)) {
nsAutoString statusArg;
if (GetStatusArg(status, statusArg)) {
- mProgressSink->OnStatus(this, mListenerContext, status, statusArg.get());
+ mProgressSink->OnStatus(this, nullptr, status, statusArg.get());
}
}
if (progress) {
- mProgressSink->OnProgress(this, mListenerContext, progress, progressMax);
+ mProgressSink->OnProgress(this, nullptr, progress, progressMax);
}
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsBaseChannel::nsIInterfaceRequestor
@@ -851,17 +835,17 @@ nsBaseChannel::OnStartRequest(nsIRequest
// Now, the general type sniffers. Skip this if we have none.
if (mLoadFlags & LOAD_CALL_CONTENT_SNIFFERS)
mPump->PeekStream(CallTypeSniffers, static_cast<nsIChannel*>(this));
}
SUSPEND_PUMP_FOR_SCOPE();
if (mListener) // null in case of redirect
- return mListener->OnStartRequest(this, mListenerContext);
+ return mListener->OnStartRequest(this, nullptr);
return NS_OK;
}
NS_IMETHODIMP
nsBaseChannel::OnStopRequest(nsIRequest *request, nsISupports *ctxt,
nsresult status)
{
// If both mStatus and status are failure codes, we keep mStatus as-is since
@@ -870,17 +854,17 @@ nsBaseChannel::OnStopRequest(nsIRequest
mStatus = status;
// Cause Pending to return false.
mPump = nullptr;
mRequest = nullptr;
mPumpingData = false;
if (mListener) // null in case of redirect
- mListener->OnStopRequest(this, mListenerContext, mStatus);
+ mListener->OnStopRequest(this, nullptr, mStatus);
ChannelDone();
// No need to suspend pump in this scope since we will not be receiving
// any more events from it.
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nullptr, mStatus);
@@ -896,17 +880,17 @@ nsBaseChannel::OnStopRequest(nsIRequest
NS_IMETHODIMP
nsBaseChannel::OnDataAvailable(nsIRequest *request, nsISupports *ctxt,
nsIInputStream *stream, uint64_t offset,
uint32_t count)
{
SUSPEND_PUMP_FOR_SCOPE();
- nsresult rv = mListener->OnDataAvailable(this, mListenerContext, stream,
+ nsresult rv = mListener->OnDataAvailable(this, nullptr, stream,
offset, count);
if (mSynthProgressEvents && NS_SUCCEEDED(rv)) {
int64_t prog = offset + count;
if (NS_IsMainThread()) {
OnTransportStatus(nullptr, NS_NET_STATUS_READING, prog, mContentLength);
} else {
class OnTransportStatusAsyncEvent : public mozilla::Runnable
{
--- a/netwerk/base/nsBaseChannel.h
+++ b/netwerk/base/nsBaseChannel.h
@@ -243,17 +243,16 @@ private:
mProgressSink = nullptr;
mQueriedProgressSink = false;
OnCallbacksChanged();
}
// Called when our channel is done. This should drop no-longer-needed pointers.
void ChannelDone() {
mListener = nullptr;
- mListenerContext = nullptr;
OnChannelDone();
}
// Handle an async redirect callback. This will only be called if we
// returned success from AsyncOpen while posting a redirect runnable.
void HandleAsyncRedirect(nsIChannel* newChannel);
void ContinueHandleAsyncRedirect(nsresult result);
nsresult ContinueRedirect();
@@ -303,17 +302,16 @@ private:
uint32_t mRedirectFlags;
protected:
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsILoadInfo> mLoadInfo;
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsIStreamListener> mListener;
- nsCOMPtr<nsISupports> mListenerContext;
nsresult mStatus;
uint32_t mContentDispositionHint;
nsAutoPtr<nsString> mContentDispositionFilename;
int64_t mContentLength;
bool mWasOpened;
friend class mozilla::net::PrivateBrowsingChannel<nsBaseChannel>;
};
--- a/netwerk/base/nsIChannel.idl
+++ b/netwerk/base/nsIChannel.idl
@@ -145,24 +145,21 @@ interface nsIChannel : nsIRequest
* @return blocking input stream to the channel's data.
*
* NOTE: nsIChannel implementations are not required to implement this
* method. Moreover, since this method may block the calling thread, it
* should not be called on a thread that processes UI events. Like any
* other nsIChannel method it must not be called on any thread other
* than the XPCOM main thread.
*
+ * This method performs content security check first.
+ *
* NOTE: Implementations should throw NS_ERROR_IN_PROGRESS if the channel
* is reopened.
*/
- nsIInputStream open();
-
- /**
- * Performs content security check and calls open()
- */
nsIInputStream open2();
/**
* Asynchronously open this channel. Data is fed to the specified stream
* listener as it becomes available. The stream listener's methods are
* called on the thread that calls asyncOpen and are not called until
* after asyncOpen returns. If asyncOpen returns successfully, the
* channel promises to call at least onStartRequest and onStopRequest.
@@ -179,28 +176,24 @@ interface nsIChannel : nsIRequest
*
* If asyncOpen returns successfully, the channel is responsible for
* keeping itself alive until it has called onStopRequest on aListener or
* called onChannelRedirect.
*
* Implementations are allowed to synchronously add themselves to the
* associated load group (if any).
*
+ * This method performs content security check first.
+ *
* NOTE: Implementations should throw NS_ERROR_ALREADY_OPENED if the
* channel is reopened.
*
* @param aListener the nsIStreamListener implementation
- * @param aContext an opaque parameter forwarded to aListener's methods
* @see nsIChannelEventSink for onChannelRedirect
*/
- void asyncOpen(in nsIStreamListener aListener, in nsISupports aContext);
-
- /**
- * Performs content security check and calls asyncOpen().
- */
void asyncOpen2(in nsIStreamListener aListener);
/**************************************************************************
* Channel specific load flags:
*
* Bits 16-31 are reserved for future use by this interface or one of its
* derivatives (e.g., see nsICachingChannel).
*/
--- a/netwerk/base/nsIOService.cpp
+++ b/netwerk/base/nsIOService.cpp
@@ -20,17 +20,16 @@
#include "nsIPrefService.h"
#include "nsXPCOM.h"
#include "nsIProxiedProtocolHandler.h"
#include "nsIProxyInfo.h"
#include "nsEscape.h"
#include "nsNetUtil.h"
#include "nsNetCID.h"
#include "nsCRT.h"
-#include "nsSecCheckWrapChannel.h"
#include "nsSimpleNestedURI.h"
#include "nsTArray.h"
#include "nsIConsoleService.h"
#include "nsIUploadChannel2.h"
#include "nsXULAppAPI.h"
#include "nsIScriptError.h"
#include "nsIScriptSecurityManager.h"
#include "nsIProtocolProxyCallback.h"
@@ -864,59 +863,26 @@ nsIOService::NewChannelFromURIWithProxyF
if (NS_FAILED(rv))
return rv;
uint32_t protoFlags;
rv = handler->DoGetProtocolFlags(aURI, &protoFlags);
if (NS_FAILED(rv))
return rv;
- // Ideally we are creating new channels by calling NewChannel2 (NewProxiedChannel2).
- // Keep in mind that Addons can implement their own Protocolhandlers, hence
- // NewChannel2() might *not* be implemented.
- // We do not want to break those addons, therefore we first try to create a channel
- // calling NewChannel2(); if that fails:
- // * we fall back to creating a channel by calling NewChannel()
- // * wrap the addon channel
- // * and attach the loadInfo to the channel wrapper
nsCOMPtr<nsIChannel> channel;
nsCOMPtr<nsIProxiedProtocolHandler> pph = do_QueryInterface(handler);
if (pph) {
rv = pph->NewProxiedChannel2(aURI, nullptr, aProxyFlags, aProxyURI,
aLoadInfo, getter_AddRefs(channel));
- // if calling NewProxiedChannel2() fails we try to fall back to
- // creating a new proxied channel by calling NewProxiedChannel().
- if (NS_FAILED(rv)) {
- rv = pph->NewProxiedChannel(aURI, nullptr, aProxyFlags, aProxyURI,
- getter_AddRefs(channel));
- NS_ENSURE_SUCCESS(rv, rv);
-
- // The protocol handler does not implement NewProxiedChannel2, so
- // maybe we need to wrap the channel (see comment in MaybeWrap
- // function).
- channel = nsSecCheckWrapChannel::MaybeWrap(channel, aLoadInfo);
- }
+ NS_ENSURE_SUCCESS(rv, rv);
}
else {
rv = handler->NewChannel2(aURI, aLoadInfo, getter_AddRefs(channel));
- // if an implementation of NewChannel2() is missing we try to fall back to
- // creating a new channel by calling NewChannel().
- if (rv == NS_ERROR_NOT_IMPLEMENTED ||
- rv == NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED) {
- LOG(("NewChannel2 not implemented rv=%" PRIx32
- ". Falling back to NewChannel\n", static_cast<uint32_t>(rv)));
- rv = handler->NewChannel(aURI, getter_AddRefs(channel));
- if (NS_FAILED(rv)) {
- return rv;
- }
- // The protocol handler does not implement NewChannel2, so
- // maybe we need to wrap the channel (see comment in MaybeWrap
- // function).
- channel = nsSecCheckWrapChannel::MaybeWrap(channel, aLoadInfo);
- } else if (NS_FAILED(rv)) {
+ if (NS_FAILED(rv)) {
return rv;
}
}
// Make sure that all the individual protocolhandlers attach a loadInfo.
if (aLoadInfo) {
// make sure we have the same instance of loadInfo on the newly created channel
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
--- a/netwerk/base/nsNetUtil.cpp
+++ b/netwerk/base/nsNetUtil.cpp
@@ -2691,30 +2691,26 @@ nsresult NS_MakeRandomInvalidURLString(n
}
#undef NS_FAKE_SCHEME
#undef NS_FAKE_TLD
nsresult NS_MaybeOpenChannelUsingOpen2(nsIChannel* aChannel,
nsIInputStream **aStream)
{
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
- if (loadInfo && loadInfo->GetSecurityMode() != 0) {
- return aChannel->Open2(aStream);
- }
- return aChannel->Open(aStream);
+ MOZ_ASSERT(loadInfo && loadInfo->GetSecurityMode() != 0);
+ return aChannel->Open2(aStream);
}
nsresult NS_MaybeOpenChannelUsingAsyncOpen2(nsIChannel* aChannel,
nsIStreamListener *aListener)
{
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
- if (loadInfo && loadInfo->GetSecurityMode() != 0) {
- return aChannel->AsyncOpen2(aListener);
- }
- return aChannel->AsyncOpen(aListener, nullptr);
+ MOZ_ASSERT(loadInfo && loadInfo->GetSecurityMode() != 0);
+ return aChannel->AsyncOpen2(aListener);
}
nsresult
NS_CheckIsJavaCompatibleURLString(nsCString &urlString, bool *result)
{
*result = false; // Default to "no"
nsresult rv = NS_OK;
deleted file mode 100644
--- a/netwerk/base/nsSecCheckWrapChannel.cpp
+++ /dev/null
@@ -1,196 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 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/. */
-
-#include "nsContentSecurityManager.h"
-#include "nsSecCheckWrapChannel.h"
-#include "nsIForcePendingChannel.h"
-#include "nsIStreamListener.h"
-#include "mozilla/Logging.h"
-#include "nsCOMPtr.h"
-
-namespace mozilla {
-namespace net {
-
-static LazyLogModule gChannelWrapperLog("ChannelWrapper");
-#define CHANNELWRAPPERLOG(args) MOZ_LOG(gChannelWrapperLog, LogLevel::Debug, args)
-
-NS_IMPL_ADDREF(nsSecCheckWrapChannelBase)
-NS_IMPL_RELEASE(nsSecCheckWrapChannelBase)
-
-NS_INTERFACE_MAP_BEGIN(nsSecCheckWrapChannelBase)
- NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIHttpChannel, mHttpChannel)
- NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIHttpChannelInternal, mHttpChannelInternal)
- NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIHttpChannel)
- NS_INTERFACE_MAP_ENTRY(nsIRequest)
- NS_INTERFACE_MAP_ENTRY(nsIChannel)
- NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIUploadChannel, mUploadChannel)
- NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIUploadChannel2, mUploadChannel2)
- NS_INTERFACE_MAP_ENTRY(nsISecCheckWrapChannel)
-NS_INTERFACE_MAP_END
-
-//---------------------------------------------------------
-// nsSecCheckWrapChannelBase implementation
-//---------------------------------------------------------
-
-nsSecCheckWrapChannelBase::nsSecCheckWrapChannelBase(nsIChannel* aChannel)
- : mChannel(aChannel)
- , mHttpChannel(do_QueryInterface(aChannel))
- , mHttpChannelInternal(do_QueryInterface(aChannel))
- , mRequest(do_QueryInterface(aChannel))
- , mUploadChannel(do_QueryInterface(aChannel))
- , mUploadChannel2(do_QueryInterface(aChannel))
-{
- MOZ_ASSERT(mChannel, "can not create a channel wrapper without a channel");
-}
-
-nsSecCheckWrapChannelBase::~nsSecCheckWrapChannelBase()
-{
-}
-
-//---------------------------------------------------------
-// nsISecCheckWrapChannel implementation
-//---------------------------------------------------------
-
-NS_IMETHODIMP
-nsSecCheckWrapChannelBase::GetInnerChannel(nsIChannel **aInnerChannel)
-{
- NS_IF_ADDREF(*aInnerChannel = mChannel);
- return NS_OK;
-}
-
-//---------------------------------------------------------
-// nsSecCheckWrapChannel implementation
-//---------------------------------------------------------
-
-nsSecCheckWrapChannel::nsSecCheckWrapChannel(nsIChannel* aChannel,
- nsILoadInfo* aLoadInfo)
- : nsSecCheckWrapChannelBase(aChannel)
- , mLoadInfo(aLoadInfo)
-{
- {
- nsCOMPtr<nsIURI> uri;
- mChannel->GetURI(getter_AddRefs(uri));
- CHANNELWRAPPERLOG(("nsSecCheckWrapChannel::nsSecCheckWrapChannel [%p] (%s)",
- this, uri ? uri->GetSpecOrDefault().get() : ""));
- }
-}
-
-// static
-already_AddRefed<nsIChannel>
-nsSecCheckWrapChannel::MaybeWrap(nsIChannel* aChannel, nsILoadInfo* aLoadInfo)
-{
- // Maybe a custom protocol handler actually returns a gecko
- // http/ftpChannel - To check this we will check whether the channel
- // implements a gecko non-scriptable interface e.g. nsIForcePendingChannel.
- nsCOMPtr<nsIForcePendingChannel> isGeckoChannel = do_QueryInterface(aChannel);
-
- nsCOMPtr<nsIChannel> channel;
- if (isGeckoChannel) {
- // If it is a gecko channel (ftp or http) we do not need to wrap it.
- channel = aChannel;
- channel->SetLoadInfo(aLoadInfo);
- } else {
- channel = new nsSecCheckWrapChannel(aChannel, aLoadInfo);
- }
- return channel.forget();
-}
-
-nsSecCheckWrapChannel::~nsSecCheckWrapChannel()
-{
-}
-
-//---------------------------------------------------------
-// SecWrapChannelStreamListener helper
-//---------------------------------------------------------
-
-class SecWrapChannelStreamListener final : public nsIStreamListener
-{
- public:
- SecWrapChannelStreamListener(nsIRequest *aRequest,
- nsIStreamListener *aStreamListener)
- : mRequest(aRequest)
- , mListener(aStreamListener) {}
-
- NS_DECL_ISUPPORTS
- NS_DECL_NSISTREAMLISTENER
- NS_DECL_NSIREQUESTOBSERVER
-
- private:
- ~SecWrapChannelStreamListener() {}
-
- nsCOMPtr<nsIRequest> mRequest;
- nsCOMPtr<nsIStreamListener> mListener;
-};
-
-NS_IMPL_ISUPPORTS(SecWrapChannelStreamListener,
- nsIStreamListener,
- nsIRequestObserver)
-
-NS_IMETHODIMP
-SecWrapChannelStreamListener::OnStartRequest(nsIRequest *aRequest,
- nsISupports *aContext)
-{
- return mListener->OnStartRequest(mRequest, aContext);
-}
-
-NS_IMETHODIMP
-SecWrapChannelStreamListener::OnStopRequest(nsIRequest *aRequest,
- nsISupports *aContext,
- nsresult aStatus)
-{
- return mListener->OnStopRequest(mRequest, aContext, aStatus);
-}
-
-NS_IMETHODIMP
-SecWrapChannelStreamListener::OnDataAvailable(nsIRequest *aRequest,
- nsISupports *aContext,
- nsIInputStream *aInStream,
- uint64_t aOffset,
- uint32_t aCount)
-{
- return mListener->OnDataAvailable(mRequest, aContext, aInStream, aOffset, aCount);
-}
-
-//---------------------------------------------------------
-// nsIChannel implementation
-//---------------------------------------------------------
-
-NS_IMETHODIMP
-nsSecCheckWrapChannel::GetLoadInfo(nsILoadInfo** aLoadInfo)
-{
- CHANNELWRAPPERLOG(("nsSecCheckWrapChannel::GetLoadInfo() [%p]",this));
- NS_IF_ADDREF(*aLoadInfo = mLoadInfo);
- return NS_OK;
-}
-
-NS_IMETHODIMP
-nsSecCheckWrapChannel::SetLoadInfo(nsILoadInfo* aLoadInfo)
-{
- CHANNELWRAPPERLOG(("nsSecCheckWrapChannel::SetLoadInfo() [%p]", this));
- mLoadInfo = aLoadInfo;
- return NS_OK;
-}
-
-NS_IMETHODIMP
-nsSecCheckWrapChannel::AsyncOpen2(nsIStreamListener *aListener)
-{
- nsCOMPtr<nsIStreamListener> secWrapChannelListener =
- new SecWrapChannelStreamListener(this, aListener);
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, secWrapChannelListener);
- NS_ENSURE_SUCCESS(rv, rv);
- return AsyncOpen(secWrapChannelListener, nullptr);
-}
-
-NS_IMETHODIMP
-nsSecCheckWrapChannel::Open2(nsIInputStream** aStream)
-{
- nsCOMPtr<nsIStreamListener> listener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- NS_ENSURE_SUCCESS(rv, rv);
- return Open(aStream);
-}
-
-} // namespace net
-} // namespace mozilla
deleted file mode 100644
--- a/netwerk/base/nsSecCheckWrapChannel.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 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 nsSecCheckWrapChannel_h__
-#define nsSecCheckWrapChannel_h__
-
-#include "nsIHttpChannel.h"
-#include "nsIHttpChannelInternal.h"
-#include "nsIUploadChannel.h"
-#include "nsIUploadChannel2.h"
-#include "nsISecCheckWrapChannel.h"
-#include "nsIWyciwygChannel.h"
-#include "mozilla/LoadInfo.h"
-
-namespace mozilla {
-namespace net {
-
-/*
- * The nsSecCheckWrapChannelBase wraps channels that do *not*
- * * provide a newChannel2() implementation
- * * provide get/setLoadInfo functions
- *
- * In order to perform security checks for channels
- * a) before opening the channel, and
- * b) after redirects
- * we are attaching a loadinfo object to every channel which
- * provides information about the content-type of the channel,
- * who initiated the load, etc.
- *
- * Addon created channels might *not* provide that loadInfo object for
- * some transition time before we mark the NewChannel-API as deprecated.
- * We do not want to break those addons hence we wrap such channels
- * using the provided wrapper in this class.
- *
- * Please note that the wrapper only forwards calls for
- * * nsIRequest
- * * nsIChannel
- * * nsIHttpChannel
- * * nsIHttpChannelInternal
- * * nsIUploadChannel
- * * nsIUploadChannel2
- *
- * In case any addon needs to query the inner channel this class
- * provides a readonly function to query the wrapped channel.
- *
- */
-
-class nsSecCheckWrapChannelBase : public nsIHttpChannel
- , public nsIHttpChannelInternal
- , public nsISecCheckWrapChannel
- , public nsIUploadChannel
- , public nsIUploadChannel2
-{
-public:
- NS_FORWARD_NSIHTTPCHANNEL(mHttpChannel->)
- NS_FORWARD_NSIHTTPCHANNELINTERNAL(mHttpChannelInternal->)
- NS_FORWARD_NSICHANNEL(mChannel->)
- NS_FORWARD_NSIREQUEST(mRequest->)
- NS_FORWARD_NSIUPLOADCHANNEL(mUploadChannel->)
- NS_FORWARD_NSIUPLOADCHANNEL2(mUploadChannel2->)
- NS_DECL_NSISECCHECKWRAPCHANNEL
- NS_DECL_ISUPPORTS
-
- explicit nsSecCheckWrapChannelBase(nsIChannel* aChannel);
-
-protected:
- virtual ~nsSecCheckWrapChannelBase();
-
- nsCOMPtr<nsIChannel> mChannel;
- // We do a QI in the constructor to set the following pointers.
- nsCOMPtr<nsIHttpChannel> mHttpChannel;
- nsCOMPtr<nsIHttpChannelInternal> mHttpChannelInternal;
- nsCOMPtr<nsIRequest> mRequest;
- nsCOMPtr<nsIUploadChannel> mUploadChannel;
- nsCOMPtr<nsIUploadChannel2> mUploadChannel2;
-};
-
-/* We define a separate class here to make it clear that we're overriding
- * Get/SetLoadInfo as well as AsyncOpen2() and Open2(), rather that using
- * the forwarded implementations provided by NS_FORWARD_NSICHANNEL"
- */
-class nsSecCheckWrapChannel : public nsSecCheckWrapChannelBase
-{
-public:
- NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo) override;
- NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo) override;
-
- NS_IMETHOD AsyncOpen2(nsIStreamListener *aListener) override;
- NS_IMETHOD Open2(nsIInputStream** aStream) override;
-
- nsSecCheckWrapChannel(nsIChannel* aChannel, nsILoadInfo* aLoadInfo);
- static already_AddRefed<nsIChannel> MaybeWrap(nsIChannel* aChannel,
- nsILoadInfo* aLoadInfo);
-
-protected:
- virtual ~nsSecCheckWrapChannel();
-
- nsCOMPtr<nsILoadInfo> mLoadInfo;
-};
-
-} // namespace net
-} // namespace mozilla
-
-#endif // nsSecCheckWrapChannel_h__
--- a/netwerk/protocol/about/nsAboutCache.cpp
+++ b/netwerk/protocol/about/nsAboutCache.cpp
@@ -127,45 +127,34 @@ nsAboutCache::Channel::Init(nsIURI* aURI
rv = FlushBuffer();
if (NS_FAILED(rv)) {
NS_WARNING("Failed to flush buffer");
}
return NS_OK;
}
-NS_IMETHODIMP nsAboutCache::Channel::AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext)
+NS_IMETHODIMP nsAboutCache::Channel::AsyncOpen2(nsIStreamListener *aListener)
{
nsresult rv;
if (!mChannel) {
return NS_ERROR_UNEXPECTED;
}
// Kick the walk loop.
rv = VisitNextStorage();
if (NS_FAILED(rv)) return rv;
- MOZ_ASSERT(!aContext, "asyncOpen2() does not take a context argument");
rv = NS_MaybeOpenChannelUsingAsyncOpen2(mChannel, aListener);
if (NS_FAILED(rv)) return rv;
return NS_OK;
}
-NS_IMETHODIMP nsAboutCache::Channel::AsyncOpen2(nsIStreamListener *aListener)
-{
- return AsyncOpen(aListener, nullptr);
-}
-
-NS_IMETHODIMP nsAboutCache::Channel::Open(nsIInputStream * *_retval)
-{
- return NS_ERROR_NOT_IMPLEMENTED;
-}
-
NS_IMETHODIMP nsAboutCache::Channel::Open2(nsIInputStream * *_retval)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
nsresult
nsAboutCache::Channel::ParseURI(nsIURI * uri, nsACString & storage)
{
--- a/netwerk/protocol/about/nsAboutCache.h
+++ b/netwerk/protocol/about/nsAboutCache.h
@@ -61,19 +61,17 @@ protected:
class Channel final : public nsIChannel
, public nsICacheStorageVisitor
{
NS_DECL_ISUPPORTS
NS_DECL_NSICACHESTORAGEVISITOR
NS_FORWARD_SAFE_NSIREQUEST(mChannel)
NS_FORWARD_SAFE_NSICHANNEL_SUBSET(mChannel)
- NS_IMETHOD AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext) override;
NS_IMETHOD AsyncOpen2(nsIStreamListener *aListener) override;
- NS_IMETHOD Open(nsIInputStream * *_retval) override;
NS_IMETHOD Open2(nsIInputStream * *_retval) override;
private:
virtual ~Channel() {}
public:
MOZ_MUST_USE nsresult Init(nsIURI* aURI, nsILoadInfo* aLoadInfo);
MOZ_MUST_USE nsresult ParseURI(nsIURI * uri, nsACString & storage);
--- a/netwerk/protocol/data/DataChannelChild.cpp
+++ b/netwerk/protocol/data/DataChannelChild.cpp
@@ -43,23 +43,19 @@ DataChannelChild::ConnectParent(uint32_t
return NS_OK;
}
NS_IMETHODIMP
DataChannelChild::CompleteRedirectSetup(nsIStreamListener *aListener,
nsISupports *aContext)
{
nsresult rv;
- if (mLoadInfo && mLoadInfo->GetEnforceSecurity()) {
- MOZ_ASSERT(!aContext, "aContext should be null!");
- rv = AsyncOpen2(aListener);
- }
- else {
- rv = AsyncOpen(aListener, aContext);
- }
+ MOZ_ASSERT(mLoadInfo && mLoadInfo->GetEnforceSecurity());
+ MOZ_ASSERT(!aContext, "aContext should be null!");
+ rv = AsyncOpen2(aListener);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
if (mIPCOpen) {
Unused << Send__delete__(this);
}
return NS_OK;
--- a/netwerk/protocol/file/FileChannelChild.cpp
+++ b/netwerk/protocol/file/FileChannelChild.cpp
@@ -39,23 +39,19 @@ FileChannelChild::ConnectParent(uint32_t
}
NS_IMETHODIMP
FileChannelChild::CompleteRedirectSetup(nsIStreamListener *listener,
nsISupports *ctx)
{
nsresult rv;
- if (mLoadInfo && mLoadInfo->GetEnforceSecurity()) {
- MOZ_ASSERT(!ctx, "Context should be null");
- rv = AsyncOpen2(listener);
- } else {
- rv = AsyncOpen(listener, ctx);
- }
-
+ MOZ_ASSERT(mLoadInfo && mLoadInfo->GetEnforceSecurity());
+ MOZ_ASSERT(!ctx, "Context should be null");
+ rv = AsyncOpen2(listener);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
if (mIPCOpen) {
Unused << Send__delete__(this);
}
--- a/netwerk/protocol/ftp/FTPChannelChild.cpp
+++ b/netwerk/protocol/ftp/FTPChannelChild.cpp
@@ -6,16 +6,17 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/net/NeckoChild.h"
#include "mozilla/net/ChannelDiverterChild.h"
#include "mozilla/net/FTPChannelChild.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/DocGroup.h"
#include "mozilla/dom/TabChild.h"
+#include "nsContentSecurityManager.h"
#include "nsContentUtils.h"
#include "nsFtpProtocolHandler.h"
#include "nsITabChild.h"
#include "nsStringStream.h"
#include "nsNetUtil.h"
#include "base/compiler_specific.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/ipc/URIUtils.h"
@@ -144,30 +145,36 @@ FTPChannelChild::GetUploadStream(nsIInpu
{
NS_ENSURE_ARG_POINTER(stream);
*stream = mUploadStream;
NS_IF_ADDREF(*stream);
return NS_OK;
}
NS_IMETHODIMP
-FTPChannelChild::AsyncOpen(::nsIStreamListener* listener, nsISupports* aContext)
+FTPChannelChild::AsyncOpen2(::nsIStreamListener* aListener)
{
+ nsCOMPtr<nsIStreamListener> listener = aListener;
+ nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+ if (NS_FAILED(rv)) {
+ mCallbacks = nullptr;
+ return rv;
+ }
+
LOG(("FTPChannelChild::AsyncOpen [this=%p]\n", this));
NS_ENSURE_TRUE((gNeckoChild), NS_ERROR_FAILURE);
NS_ENSURE_TRUE(!static_cast<ContentChild*>(gNeckoChild->Manager())->
IsShuttingDown(), NS_ERROR_FAILURE);
NS_ENSURE_ARG_POINTER(listener);
NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);
NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
// Port checked in parent, but duplicate here so we can return with error
// immediately, as we've done since before e10s.
- nsresult rv;
rv = NS_CheckPortSafety(nsBaseChannel::URI()); // Need to disambiguate,
// because in the child ipdl,
// a typedef URI is defined...
if (NS_FAILED(rv))
return rv;
mozilla::dom::TabChild* tabChild = nullptr;
nsCOMPtr<nsITabChild> iTabChild;
@@ -178,17 +185,16 @@ FTPChannelChild::AsyncOpen(::nsIStreamLi
if (iTabChild) {
tabChild = static_cast<mozilla::dom::TabChild*>(iTabChild.get());
}
if (MissingRequiredTabChild(tabChild, "ftp")) {
return NS_ERROR_ILLEGAL_VALUE;
}
mListener = listener;
- mListenerContext = aContext;
// add ourselves to the load group.
if (mLoadGroup)
mLoadGroup->AddRequest(this, nullptr);
mozilla::ipc::AutoIPCStream autoStream;
autoStream.Serialize(mUploadStream,
static_cast<ContentChild*>(gNeckoChild->Manager()));
@@ -337,23 +343,22 @@ FTPChannelChild::DoOnStartRequest(const
if (NS_FAILED(rv)) {
Cancel(rv);
}
} else {
Cancel(rv);
}
AutoEventEnqueuer ensureSerialDispatch(mEventQ);
- rv = mListener->OnStartRequest(this, mListenerContext);
+ rv = mListener->OnStartRequest(this, nullptr);
if (NS_FAILED(rv))
Cancel(rv);
if (mDivertingToParent) {
mListener = nullptr;
- mListenerContext = nullptr;
if (mLoadGroup) {
mLoadGroup->RemoveRequest(this, nullptr, mStatus);
}
}
}
class FTPDataAvailableEvent : public NeckoTargetChannelEvent<FTPChannelChild>
{
@@ -473,17 +478,17 @@ FTPChannelChild::DoOnDataAvailable(const
count,
NS_ASSIGNMENT_DEPEND);
if (NS_FAILED(rv)) {
Cancel(rv);
return;
}
AutoEventEnqueuer ensureSerialDispatch(mEventQ);
- rv = mListener->OnDataAvailable(this, mListenerContext,
+ rv = mListener->OnDataAvailable(this, nullptr,
stringStream, offset, count);
if (NS_FAILED(rv))
Cancel(rv);
stringStream->Close();
}
class FTPStopRequestEvent : public NeckoTargetChannelEvent<FTPChannelChild>
{
@@ -600,17 +605,17 @@ FTPChannelChild::DoOnStopRequest(const n
mUnknownDecoderEventQ.AppendElement(
MakeUnique<MaybeDivertOnStopFTPEvent>(this, aChannelStatus));
}
{ // Ensure that all queued ipdl events are dispatched before
// we initiate protocol deletion below.
mIsPending = false;
AutoEventEnqueuer ensureSerialDispatch(mEventQ);
- (void)mListener->OnStopRequest(this, mListenerContext, aChannelStatus);
+ (void)mListener->OnStopRequest(this, nullptr, aChannelStatus);
if (NS_FAILED(aChannelStatus) && !aErrorMsg.IsEmpty()) {
nsCOMPtr<nsIPrompt> prompter;
GetCallback(prompter);
if (prompter) {
nsCOMPtr<nsIRunnable> alertEvent;
if (aUseUTF8) {
alertEvent = new nsFtpChildAsyncAlert(prompter,
@@ -620,17 +625,16 @@ FTPChannelChild::DoOnStopRequest(const n
NS_ConvertASCIItoUTF16(aErrorMsg));
}
Dispatch(alertEvent.forget());
}
}
mListener = nullptr;
- mListenerContext = nullptr;
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nullptr, aChannelStatus);
}
// This calls NeckoChild::DeallocPFTPChannelChild(), which deletes |this| if IPDL
// holds the last reference. Don't rely on |this| existing after here!
Send__delete__(this);
@@ -664,25 +668,24 @@ FTPChannelChild::DoFailedAsyncOpen(const
LOG(("FTPChannelChild::DoFailedAsyncOpen [this=%p status=%" PRIx32 "]\n",
this, static_cast<uint32_t>(statusCode)));
mStatus = statusCode;
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nullptr, statusCode);
if (mListener) {
- mListener->OnStartRequest(this, mListenerContext);
+ mListener->OnStartRequest(this, nullptr);
mIsPending = false;
- mListener->OnStopRequest(this, mListenerContext, statusCode);
+ mListener->OnStopRequest(this, nullptr, statusCode);
} else {
mIsPending = false;
}
mListener = nullptr;
- mListenerContext = nullptr;
if (mIPCOpen)
Send__delete__(this);
}
class FTPFlushedForDiversionEvent : public NeckoTargetChannelEvent<FTPChannelChild>
{
public:
@@ -859,17 +862,16 @@ FTPChannelChild::CompleteRedirectSetup(n
LOG(("FTPChannelChild::CompleteRedirectSetup [this=%p]\n", this));
NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);
NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
mIsPending = true;
mWasOpened = true;
mListener = listener;
- mListenerContext = aContext;
// add ourselves to the load group.
if (mLoadGroup)
mLoadGroup->AddRequest(this, nullptr);
// We already have an open IPDL connection to the parent. If on-modify-request
// listeners or load group observers canceled us, let the parent handle it
// and send it back to us naturally.
--- a/netwerk/protocol/ftp/FTPChannelChild.h
+++ b/netwerk/protocol/ftp/FTPChannelChild.h
@@ -58,17 +58,17 @@ public:
NS_IMETHOD Suspend() override;
NS_IMETHOD Resume() override;
explicit FTPChannelChild(nsIURI* uri);
void AddIPDLReference();
void ReleaseIPDLReference();
- NS_IMETHOD AsyncOpen(nsIStreamListener* listener, nsISupports* aContext) override;
+ NS_IMETHOD AsyncOpen2(nsIStreamListener* listener) override;
// Note that we handle this ourselves, overriding the nsBaseChannel
// default behavior, in order to be e10s-friendly.
NS_IMETHOD IsPending(bool* result) override;
nsresult OpenContentStream(bool async,
nsIInputStream** stream,
nsIChannel** channel) override;
--- a/netwerk/protocol/ftp/FTPChannelParent.cpp
+++ b/netwerk/protocol/ftp/FTPChannelParent.cpp
@@ -178,23 +178,18 @@ FTPChannelParent::DoAsyncOpen(const URIP
if (NS_FAILED(rv))
return SendFailedAsyncOpen(rv);
}
rv = ftpChan->ResumeAt(aStartPos, aEntityID);
if (NS_FAILED(rv))
return SendFailedAsyncOpen(rv);
- if (loadInfo && loadInfo->GetEnforceSecurity()) {
- rv = ftpChan->AsyncOpen2(this);
- }
- else {
- rv = ftpChan->AsyncOpen(this, nullptr);
- }
-
+ MOZ_ASSERT(loadInfo && loadInfo->GetEnforceSecurity());
+ rv = ftpChan->AsyncOpen2(this);
if (NS_FAILED(rv))
return SendFailedAsyncOpen(rv);
return true;
}
bool
FTPChannelParent::ConnectChannel(const uint32_t& channelId)
--- a/netwerk/protocol/http/HttpBaseChannel.cpp
+++ b/netwerk/protocol/http/HttpBaseChannel.cpp
@@ -292,17 +292,16 @@ HttpBaseChannel::ReleaseMainThreadOnlyRe
arrayToRelease.AppendElement(mProgressSink.forget());
arrayToRelease.AppendElement(mReferrer.forget());
arrayToRelease.AppendElement(mApplicationCache.forget());
arrayToRelease.AppendElement(mAPIRedirectToURI.forget());
arrayToRelease.AppendElement(mProxyURI.forget());
arrayToRelease.AppendElement(mPrincipal.forget());
arrayToRelease.AppendElement(mTopWindowURI.forget());
arrayToRelease.AppendElement(mListener.forget());
- arrayToRelease.AppendElement(mListenerContext.forget());
arrayToRelease.AppendElement(mCompressListener.forget());
if (mAddedAsNonTailRequest) {
// RemoveNonTailRequest() on our request context must be called on the main thread
MOZ_RELEASE_ASSERT(mRequestContext, "Someone released rc or set flags w/o having it?");
nsCOMPtr<nsISupports> nonTailRemover(new NonTailRemover(mRequestContext));
arrayToRelease.AppendElement(nonTailRemover.forget());
@@ -779,40 +778,35 @@ HttpBaseChannel::GetContentLength(int64_
NS_IMETHODIMP
HttpBaseChannel::SetContentLength(int64_t value)
{
MOZ_ASSERT_UNREACHABLE("HttpBaseChannel::SetContentLength");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
-HttpBaseChannel::Open(nsIInputStream **aResult)
-{
- NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_IN_PROGRESS);
-
- if (!gHttpHandler->Active()) {
- LOG(("HttpBaseChannel::Open after HTTP shutdown..."));
- return NS_ERROR_NOT_AVAILABLE;
- }
-
- return NS_ImplementChannelOpen(this, aResult);
-}
-
-NS_IMETHODIMP
HttpBaseChannel::Open2(nsIInputStream** aStream)
{
if (!gHttpHandler->Active()) {
LOG(("HttpBaseChannel::Open after HTTP shutdown..."));
return NS_ERROR_NOT_AVAILABLE;
}
nsCOMPtr<nsIStreamListener> listener;
nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
NS_ENSURE_SUCCESS(rv, rv);
- return Open(aStream);
+
+ NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_IN_PROGRESS);
+
+ if (!gHttpHandler->Active()) {
+ LOG(("HttpBaseChannel::Open after HTTP shutdown..."));
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ return NS_ImplementChannelOpen(this, aStream);
}
//-----------------------------------------------------------------------------
// HttpBaseChannel::nsIUploadChannel
//-----------------------------------------------------------------------------
NS_IMETHODIMP
HttpBaseChannel::GetUploadStream(nsIInputStream **stream)
@@ -1121,17 +1115,17 @@ HttpBaseChannel::SetApplyConversion(bool
}
nsresult
HttpBaseChannel::DoApplyContentConversions(nsIStreamListener* aNextListener,
nsIStreamListener** aNewNextListener)
{
return DoApplyContentConversions(aNextListener,
aNewNextListener,
- mListenerContext);
+ nullptr);
}
// create a listener chain that looks like this
// http-channel -> decompressor (n times) -> InterceptFailedOnSTop -> channel-creator-listener
//
// we need to do this because not every decompressor has fully streamed output so
// may need a call to OnStopRequest to identify its completion state.. and if it
// creates an error there the channel status code needs to be updated before calling
@@ -3301,48 +3295,47 @@ HttpBaseChannel::SetNewListener(nsIStrea
//-----------------------------------------------------------------------------
void
HttpBaseChannel::ReleaseListeners()
{
MOZ_ASSERT(NS_IsMainThread(), "Should only be called on the main thread.");
mListener = nullptr;
- mListenerContext = nullptr;
mCallbacks = nullptr;
mProgressSink = nullptr;
mCompressListener = nullptr;
}
void
HttpBaseChannel::DoNotifyListener()
{
LOG(("HttpBaseChannel::DoNotifyListener this=%p", this));
if (mListener) {
MOZ_ASSERT(!mOnStartRequestCalled,
"We should not call OnStartRequest twice");
nsCOMPtr<nsIStreamListener> listener = mListener;
- listener->OnStartRequest(this, mListenerContext);
+ listener->OnStartRequest(this, nullptr);
mOnStartRequestCalled = true;
}
// Make sure mIsPending is set to false. At this moment we are done from
// the point of view of our consumer and we have to report our self
// as not-pending.
mIsPending = false;
if (mListener) {
MOZ_ASSERT(!mOnStopRequestCalled,
"We should not call OnStopRequest twice");
nsCOMPtr<nsIStreamListener> listener = mListener;
- listener->OnStopRequest(this, mListenerContext, mStatus);
+ listener->OnStopRequest(this, nullptr, mStatus);
mOnStopRequestCalled = true;
}
// notify "http-on-stop-connect" observers
gHttpHandler->OnStopRequest(this);
// This channel has finished its job, potentially release any tail-blocked
--- a/netwerk/protocol/http/HttpBaseChannel.h
+++ b/netwerk/protocol/http/HttpBaseChannel.h
@@ -144,17 +144,16 @@ public:
NS_IMETHOD SetContentCharset(const nsACString& aContentCharset) override;
NS_IMETHOD GetContentDisposition(uint32_t *aContentDisposition) override;
NS_IMETHOD SetContentDisposition(uint32_t aContentDisposition) override;
NS_IMETHOD GetContentDispositionFilename(nsAString& aContentDispositionFilename) override;
NS_IMETHOD SetContentDispositionFilename(const nsAString& aContentDispositionFilename) override;
NS_IMETHOD GetContentDispositionHeader(nsACString& aContentDispositionHeader) override;
NS_IMETHOD GetContentLength(int64_t *aContentLength) override;
NS_IMETHOD SetContentLength(int64_t aContentLength) override;
- NS_IMETHOD Open(nsIInputStream **aResult) override;
NS_IMETHOD Open2(nsIInputStream **aResult) override;
NS_IMETHOD GetBlockAuthPrompt(bool* aValue) override;
NS_IMETHOD SetBlockAuthPrompt(bool aValue) override;
// nsIEncodedChannel
NS_IMETHOD GetApplyConversion(bool *value) override;
NS_IMETHOD SetApplyConversion(bool value) override;
NS_IMETHOD GetContentEncodings(nsIUTF8StringEnumerator** aEncodings) override;
@@ -498,17 +497,16 @@ protected:
nsCOMPtr<nsIProgressEventSink> mProgressSink;
nsCOMPtr<nsIURI> mReferrer;
nsCOMPtr<nsIApplicationCache> mApplicationCache;
nsCOMPtr<nsIURI> mAPIRedirectToURI;
nsCOMPtr<nsIURI> mProxyURI;
nsCOMPtr<nsIPrincipal> mPrincipal;
nsCOMPtr<nsIURI> mTopWindowURI;
nsCOMPtr<nsIStreamListener> mListener;
- nsCOMPtr<nsISupports> mListenerContext;
// An instance of nsHTTPCompressConv
nsCOMPtr<nsIStreamListener> mCompressListener;
private:
// Proxy release all members above on main thread.
void ReleaseMainThreadOnlyReferences();
bool IsCrossOriginWithReferrer();
--- a/netwerk/protocol/http/HttpChannelChild.cpp
+++ b/netwerk/protocol/http/HttpChannelChild.cpp
@@ -672,17 +672,17 @@ HttpChannelChild::OnStartRequest(const n
// Note: this is where we would notify "http-on-examine-response" observers.
// We have deliberately disabled this for child processes (see bug 806753)
//
// gHttpHandler->OnExamineResponse(this);
mTracingEnabled = false;
- DoOnStartRequest(this, mListenerContext);
+ DoOnStartRequest(this, nullptr);
}
class SyntheticDiversionListener final : public nsIStreamListener
{
RefPtr<HttpChannelChild> mChannel;
~SyntheticDiversionListener()
{
@@ -759,17 +759,16 @@ HttpChannelChild::DoOnStartRequest(nsIRe
nsresult rv = mListener->OnStartRequest(aRequest, aContext);
if (NS_FAILED(rv)) {
Cancel(rv);
return;
}
if (mDivertingToParent) {
mListener = nullptr;
- mListenerContext = nullptr;
mCompressListener = nullptr;
if (mLoadGroup) {
mLoadGroup->RemoveRequest(this, nullptr, mStatus);
}
// If the response has been synthesized in the child, then we are going
// be getting OnDataAvailable and OnStopRequest from the synthetic
// stream pump. We need to forward these back to the parent diversion
@@ -778,17 +777,17 @@ HttpChannelChild::DoOnStartRequest(nsIRe
mListener = new SyntheticDiversionListener(this);
}
return;
}
nsCOMPtr<nsIStreamListener> listener;
rv = DoApplyContentConversions(mListener, getter_AddRefs(listener),
- mListenerContext);
+ nullptr);
if (NS_FAILED(rv)) {
Cancel(rv);
} else if (listener) {
mListener = listener;
mCompressListener = listener;
}
}
@@ -958,17 +957,17 @@ HttpChannelChild::OnTransportAndData(con
nsCOMPtr<nsIInputStream> stringStream;
nsresult rv = NS_NewByteInputStream(getter_AddRefs(stringStream), data.get(),
count, NS_ASSIGNMENT_DEPEND);
if (NS_FAILED(rv)) {
Cancel(rv);
return;
}
- DoOnDataAvailable(this, mListenerContext, stringStream, offset, count);
+ DoOnDataAvailable(this, nullptr, stringStream, offset, count);
stringStream->Close();
}
void
HttpChannelChild::DoOnStatus(nsIRequest* aRequest, nsresult status)
{
LOG(("HttpChannelChild::DoOnStatus [this=%p]\n", this));
MOZ_ASSERT(NS_IsMainThread());
@@ -1168,17 +1167,17 @@ HttpChannelChild::OnStopRequest(const ns
DoPreOnStopRequest(channelStatus);
{ // We must flush the queue before we Send__delete__
// (although we really shouldn't receive any msgs after OnStop),
// so make sure this goes out of scope before then.
AutoEventEnqueuer ensureSerialDispatch(mEventQ);
- DoOnStopRequest(this, channelStatus, mListenerContext);
+ DoOnStopRequest(this, channelStatus, nullptr);
// DoOnStopRequest() calls ReleaseListeners()
}
// If unknownDecoder is involved and the received content is short we will
// know whether we need to divert to parent only after OnStopRequest of the
// listeners chain is called in DoOnStopRequest. At that moment
// unknownDecoder will call OnStartRequest of the real listeners of the
// channel including the OnStopRequest of UrlLoader which decides whether we
@@ -1621,22 +1620,19 @@ void
HttpChannelChild::DeleteSelf()
{
Send__delete__(this);
}
void HttpChannelChild::FinishInterceptedRedirect()
{
nsresult rv;
- if (mLoadInfo && mLoadInfo->GetEnforceSecurity()) {
- MOZ_ASSERT(!mInterceptedRedirectContext, "the context should be null!");
- rv = AsyncOpen2(mInterceptedRedirectListener);
- } else {
- rv = AsyncOpen(mInterceptedRedirectListener, mInterceptedRedirectContext);
- }
+ MOZ_ASSERT(mLoadInfo && mLoadInfo->GetEnforceSecurity());
+ MOZ_ASSERT(!mInterceptedRedirectContext, "the context should be null!");
+ rv = AsyncOpen2(mInterceptedRedirectListener);
mInterceptedRedirectListener = nullptr;
mInterceptedRedirectContext = nullptr;
if (mInterceptingChannel) {
mInterceptingChannel->CleanupRedirectingChannel(rv);
mInterceptingChannel = nullptr;
}
@@ -2022,17 +2018,17 @@ HttpChannelChild::Redirect3Complete(Over
RefPtr<HttpChannelChild> httpChannelChild = static_cast<HttpChannelChild*>(chan.get());
// Chrome channel has been AsyncOpen'd. Reflect this in child.
if (mRedirectChannelChild) {
if (httpChannelChild) {
httpChannelChild->mOverrideRunnable = aRunnable;
httpChannelChild->mInterceptingChannel = this;
}
rv = mRedirectChannelChild->CompleteRedirectSetup(mListener,
- mListenerContext);
+ nullptr);
}
if (!httpChannelChild || !httpChannelChild->mShouldParentIntercept) {
// The redirect channel either isn't a HttpChannelChild, or the interception
// logic wasn't triggered, so we can clean it up right here.
CleanupRedirectingChannel(rv);
if (httpChannelChild) {
httpChannelChild->mOverrideRunnable = nullptr;
@@ -2200,17 +2196,16 @@ HttpChannelChild::CompleteRedirectSetup(
* before AsyncOpen(); if it's canceled after that, OnStart/Stop will just
* get called with error code as usual. So just setup mListener and make the
* channel reflect AsyncOpen'ed state.
*/
mIsPending = true;
mWasOpened = true;
mListener = listener;
- mListenerContext = aContext;
// add ourselves to the load group.
if (mLoadGroup)
mLoadGroup->AddRequest(this, nullptr);
// We already have an open IPDL connection to the parent. If on-modify-request
// listeners or load group observers canceled us, let the parent handle it
// and send it back to us naturally.
@@ -2262,17 +2257,17 @@ HttpChannelChild::OnRedirectVerifyCallba
if (mRedirectingForSubsequentSynthesizedResponse) {
nsCOMPtr<nsIHttpChannelChild> httpChannelChild = do_QueryInterface(mRedirectChannelChild);
RefPtr<HttpChannelChild> redirectedChannel =
static_cast<HttpChannelChild*>(httpChannelChild.get());
// redirectChannel will be NULL if mRedirectChannelChild isn't a
// nsIHttpChannelChild (it could be a DataChannelChild).
RefPtr<InterceptStreamListener> streamListener =
- new InterceptStreamListener(redirectedChannel, mListenerContext);
+ new InterceptStreamListener(redirectedChannel, nullptr);
nsCOMPtr<nsIEventTarget> neckoTarget = GetNeckoTarget();
MOZ_ASSERT(neckoTarget);
nsCOMPtr<nsIInterceptedBodyCallback> callback =
mSynthesizedCallback.forget();
Unused << neckoTarget->Dispatch(
@@ -2454,18 +2449,25 @@ NS_IMETHODIMP
HttpChannelChild::GetSecurityInfo(nsISupports **aSecurityInfo)
{
NS_ENSURE_ARG_POINTER(aSecurityInfo);
NS_IF_ADDREF(*aSecurityInfo = mSecurityInfo);
return NS_OK;
}
NS_IMETHODIMP
-HttpChannelChild::AsyncOpen(nsIStreamListener *listener, nsISupports *aContext)
+HttpChannelChild::AsyncOpen2(nsIStreamListener *aListener)
{
+ nsCOMPtr<nsIStreamListener> listener = aListener;
+ nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ ReleaseListeners();
+ return rv;
+ }
+
MOZ_ASSERT(!mLoadInfo ||
mLoadInfo->GetSecurityMode() == 0 ||
mLoadInfo->GetInitialSecurityCheckDone() ||
(mLoadInfo->GetSecurityMode() == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL &&
nsContentUtils::IsSystemPrincipal(mLoadInfo->LoadingPrincipal())),
"security flags in loadInfo but asyncOpen2() not called");
LOG(("HttpChannelChild::AsyncOpen [this=%p uri=%s]\n", this, mSpec.get()));
@@ -2492,17 +2494,16 @@ HttpChannelChild::AsyncOpen(nsIStreamLis
uri->GetSpec(urispec);
tasktracer::AddLabel("HttpChannelChild::AsyncOpen %s", urispec.get());
}
#endif
// Port checked in parent, but duplicate here so we can return with error
// immediately
- nsresult rv;
rv = NS_CheckPortSafety(mURI);
if (NS_FAILED(rv))
return rv;
nsAutoCString cookie;
if (NS_SUCCEEDED(mRequestHead.GetHeader(nsHttp::Cookie, cookie))) {
mUserSetCookieHeader = cookie;
}
@@ -2519,17 +2520,16 @@ HttpChannelChild::AsyncOpen(nsIStreamLis
// process so that devtools can capture a stack trace at the
// appropriate spot. See bug 806753 for some information about why
// other http-* notifications are disabled in child processes.
gHttpHandler->OnOpeningRequest(this);
mIsPending = true;
mWasOpened = true;
mListener = listener;
- mListenerContext = aContext;
// add ourselves to the load group.
if (mLoadGroup)
mLoadGroup->AddRequest(this, nullptr);
if (mCanceled) {
// We may have been canceled already, either by on-modify-request
// listeners or by load group observers; in that case, don't create IPDL
@@ -2545,40 +2545,28 @@ HttpChannelChild::AsyncOpen(nsIStreamLis
bool shouldUpgrade = mPostRedirectChannelShouldUpgrade;
if (mPostRedirectChannelShouldIntercept ||
ShouldInterceptURI(mURI, shouldUpgrade)) {
mResponseCouldBeSynthesized = true;
nsCOMPtr<nsINetworkInterceptController> controller;
GetCallback(controller);
- mInterceptListener = new InterceptStreamListener(this, mListenerContext);
+ mInterceptListener = new InterceptStreamListener(this, nullptr);
RefPtr<InterceptedChannelContent> intercepted =
new InterceptedChannelContent(this, controller,
mInterceptListener, shouldUpgrade);
intercepted->NotifyController();
return NS_OK;
}
return ContinueAsyncOpen();
}
-NS_IMETHODIMP
-HttpChannelChild::AsyncOpen2(nsIStreamListener *aListener)
-{
- nsCOMPtr<nsIStreamListener> listener = aListener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- if (NS_WARN_IF(NS_FAILED(rv))) {
- ReleaseListeners();
- return rv;
- }
- return AsyncOpen(listener, nullptr);
-}
-
// Assigns an nsIEventTarget to our IPDL actor so that IPC messages are sent to
// the correct DocGroup/TabGroup.
void
HttpChannelChild::SetEventTarget()
{
nsCOMPtr<nsILoadInfo> loadInfo;
GetLoadInfo(getter_AddRefs(loadInfo));
--- a/netwerk/protocol/http/HttpChannelChild.h
+++ b/netwerk/protocol/http/HttpChannelChild.h
@@ -82,17 +82,16 @@ public:
// Methods HttpBaseChannel didn't implement for us or that we override.
//
// nsIRequest
NS_IMETHOD Cancel(nsresult status) override;
NS_IMETHOD Suspend() override;
NS_IMETHOD Resume() override;
// nsIChannel
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) override;
- NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext) override;
NS_IMETHOD AsyncOpen2(nsIStreamListener *aListener) override;
// HttpBaseChannel::nsIHttpChannel
NS_IMETHOD SetReferrerWithPolicy(nsIURI *referrer, uint32_t referrerPolicy) override;
NS_IMETHOD SetRequestHeader(const nsACString& aHeader,
const nsACString& aValue,
bool aMerge) override;
NS_IMETHOD SetEmptyRequestHeader(const nsACString& aHeader) override;
--- a/netwerk/protocol/http/HttpChannelParent.cpp
+++ b/netwerk/protocol/http/HttpChannelParent.cpp
@@ -387,22 +387,18 @@ HttpChannelParent::InvokeAsyncOpen(nsres
}
nsCOMPtr<nsILoadInfo> loadInfo;
rv = mChannel->GetLoadInfo(getter_AddRefs(loadInfo));
if (NS_FAILED(rv)) {
AsyncOpenFailed(rv);
return;
}
- if (loadInfo && loadInfo->GetEnforceSecurity()) {
- rv = mChannel->AsyncOpen2(mParentListener);
- }
- else {
- rv = mChannel->AsyncOpen(mParentListener, nullptr);
- }
+ MOZ_ASSERT(loadInfo && loadInfo->GetEnforceSecurity());
+ rv = mChannel->AsyncOpen2(mParentListener);
if (NS_FAILED(rv)) {
AsyncOpenFailed(rv);
}
}
namespace {
class InvokeAsyncOpen : public Runnable
{
--- a/netwerk/protocol/http/InterceptedHttpChannel.cpp
+++ b/netwerk/protocol/http/InterceptedHttpChannel.cpp
@@ -320,17 +320,17 @@ InterceptedHttpChannel::StartPump()
// for streams that support it. See bug 1388774.
Unused << GetContentLength(&mSynthesizedStreamLength);
nsresult rv = nsInputStreamPump::Create(getter_AddRefs(mPump),
mBodyReader,
0, 0, true);
NS_ENSURE_SUCCESS(rv, rv);
- rv = mPump->AsyncRead(this, mListenerContext);
+ rv = mPump->AsyncRead(this, nullptr);
NS_ENSURE_SUCCESS(rv, rv);
uint32_t suspendCount = mSuspendCount;
while (suspendCount--) {
mPump->Suspend();
}
MOZ_DIAGNOSTIC_ASSERT(!mCanceled);
@@ -351,23 +351,18 @@ InterceptedHttpChannel::OpenRedirectChan
return NS_ERROR_DOM_ABORT_ERR;
}
// Make sure to do this after we received redirect veto answer,
// i.e. after all sinks had been notified
mRedirectChannel->SetOriginalURI(mOriginalURI);
// open new channel
- if (mLoadInfo && mLoadInfo->GetEnforceSecurity()) {
- MOZ_ASSERT(!mListenerContext, "mListenerContext should be null!");
- rv = mRedirectChannel->AsyncOpen2(mListener);
- }
- else {
- rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);
- }
+ MOZ_ASSERT(mLoadInfo && mLoadInfo->GetEnforceSecurity());
+ rv = mRedirectChannel->AsyncOpen2(mListener);
NS_ENSURE_SUCCESS(rv, rv);
mStatus = NS_BINDING_REDIRECTED;
return rv;
}
void
@@ -422,20 +417,20 @@ InterceptedHttpChannel::MaybeCallStatusA
// Capture the host name on the first set of calls to avoid doing this
// string processing repeatedly.
if (mProgressReported == 0) {
nsAutoCString host;
MOZ_ALWAYS_SUCCEEDS(mURI->GetHost(host));
CopyUTF8toUTF16(host, mStatusHost);
}
- mProgressSink->OnStatus(this, mListenerContext, NS_NET_STATUS_READING,
+ mProgressSink->OnStatus(this, nullptr, NS_NET_STATUS_READING,
mStatusHost.get());
- mProgressSink->OnProgress(this, mListenerContext, progress,
+ mProgressSink->OnProgress(this, nullptr, progress,
mSynthesizedStreamLength);
mProgressReported = progress;
}
void
InterceptedHttpChannel::MaybeCallBodyCallback()
{
@@ -549,41 +544,36 @@ NS_IMETHODIMP
InterceptedHttpChannel::GetSecurityInfo(nsISupports** aSecurityInfo)
{
nsCOMPtr<nsISupports> ref(mSecurityInfo);
ref.forget(aSecurityInfo);
return NS_OK;
}
NS_IMETHODIMP
-InterceptedHttpChannel::AsyncOpen(nsIStreamListener* aListener, nsISupports* aContext)
-{
- if (mCanceled) {
- return mStatus;
- }
-
- // After this point we should try to return NS_OK and notify the listener
- // of the result.
- mListener = aListener;
-
- AsyncOpenInternal();
-
- return NS_OK;
-}
-
-NS_IMETHODIMP
InterceptedHttpChannel::AsyncOpen2(nsIStreamListener* aListener)
{
nsCOMPtr<nsIStreamListener> listener(aListener);
nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
if (NS_WARN_IF(NS_FAILED(rv))) {
Cancel(rv);
return rv;
}
- return AsyncOpen(listener, nullptr);
+
+ if (mCanceled) {
+ return mStatus;
+ }
+
+ // After this point we should try to return NS_OK and notify the listener
+ // of the result.
+ mListener = listener;
+
+ AsyncOpenInternal();
+
+ return NS_OK;
}
NS_IMETHODIMP
InterceptedHttpChannel::LogBlockedCORSRequest(const nsAString& aMessage)
{
// Synthetic responses should not trigger CORS blocking.
return NS_ERROR_NOT_IMPLEMENTED;
}
@@ -1052,17 +1042,17 @@ InterceptedHttpChannel::OnStartRequest(n
GetCallback(mProgressSink);
}
if (mPump && mLoadFlags & LOAD_CALL_CONTENT_SNIFFERS) {
mPump->PeekStream(CallTypeSniffers, static_cast<nsIChannel*>(this));
}
if (mListener) {
- mListener->OnStartRequest(this, mListenerContext);
+ mListener->OnStartRequest(this, nullptr);
}
return NS_OK;
}
NS_IMETHODIMP
InterceptedHttpChannel::OnStopRequest(nsIRequest* aRequest,
nsISupports* aContext,
nsresult aStatus)
@@ -1085,17 +1075,17 @@ InterceptedHttpChannel::OnStopRequest(ns
// Register entry to the PerformanceStorage resource timing
mozilla::dom::PerformanceStorage* performanceStorage = GetPerformanceStorage();
if (performanceStorage) {
performanceStorage->AddEntry(this, this);
}
if (mListener) {
- mListener->OnStopRequest(this, mListenerContext, mStatus);
+ mListener->OnStopRequest(this, nullptr, mStatus);
}
gHttpHandler->OnStopRequest(this);
ReleaseListeners();
return NS_OK;
}
@@ -1118,17 +1108,17 @@ InterceptedHttpChannel::OnDataAvailable(
}
if (mProgressSink) {
if (!(mLoadFlags & HttpBaseChannel::LOAD_BACKGROUND)) {
mProgress = aOffset + aCount;
MaybeCallStatusAndProgress();
}
}
- return mListener->OnDataAvailable(this, mListenerContext, aInputStream,
+ return mListener->OnDataAvailable(this, nullptr, aInputStream,
aOffset, aCount);
}
NS_IMETHODIMP
InterceptedHttpChannel::MessageDiversionStarted(ADivertableParentChannel* aParentChannel)
{
MOZ_ASSERT(!mParentChannel);
mParentChannel = aParentChannel;
--- a/netwerk/protocol/http/InterceptedHttpChannel.h
+++ b/netwerk/protocol/http/InterceptedHttpChannel.h
@@ -157,19 +157,16 @@ public:
NS_IMETHOD
Resume(void) override;
NS_IMETHOD
GetSecurityInfo(nsISupports * *aSecurityInfo) override;
NS_IMETHOD
- AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext) override;
-
- NS_IMETHOD
AsyncOpen2(nsIStreamListener *aListener) override;
NS_IMETHOD
LogBlockedCORSRequest(const nsAString & aMessage) override;
NS_IMETHOD
SetupFallbackChannel(const char * aFallbackKey) override;
--- a/netwerk/protocol/http/NullHttpChannel.cpp
+++ b/netwerk/protocol/http/NullHttpChannel.cpp
@@ -405,43 +405,25 @@ NullHttpChannel::GetContentLength(int64_
NS_IMETHODIMP
NullHttpChannel::SetContentLength(int64_t aContentLength)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
-NullHttpChannel::Open(nsIInputStream * *_retval)
-{
- return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP
NullHttpChannel::Open2(nsIInputStream** aStream)
{
- nsCOMPtr<nsIStreamListener> listener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- NS_ENSURE_SUCCESS(rv, rv);
- return Open(aStream);
-}
-
-NS_IMETHODIMP
-NullHttpChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext)
-{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
NullHttpChannel::AsyncOpen2(nsIStreamListener *aListener)
{
- nsCOMPtr<nsIStreamListener> listener = aListener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- NS_ENSURE_SUCCESS(rv, rv);
- return AsyncOpen(listener, nullptr);
+ return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
NullHttpChannel::GetContentDisposition(uint32_t *aContentDisposition)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@@ -1478,17 +1478,17 @@ nsHttpChannel::CallOnStartRequest()
// this function.
auto onStartGuard = MakeScopeExit([&] {
LOG((" calling mListener->OnStartRequest by ScopeExit [this=%p, "
"listener=%p]\n", this, mListener.get()));
MOZ_ASSERT(!mOnStartRequestCalled);
if (mListener) {
nsCOMPtr<nsIStreamListener> deleteProtector(mListener);
- deleteProtector->OnStartRequest(this, mListenerContext);
+ deleteProtector->OnStartRequest(this, nullptr);
}
mOnStartRequestCalled = true;
});
nsresult rv = EnsureMIMEOfScript(mURI, mResponseHead, mLoadInfo);
NS_ENSURE_SUCCESS(rv, rv);
@@ -1529,17 +1529,17 @@ nsHttpChannel::CallOnStartRequest()
rv = gHttpHandler->
GetStreamConverterService(getter_AddRefs(serv));
// If we failed, we just fall through to the "normal" case
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIStreamListener> converter;
rv = serv->AsyncConvertData(UNKNOWN_CONTENT_TYPE,
"*/*",
mListener,
- mListenerContext,
+ nullptr,
getter_AddRefs(converter));
if (NS_SUCCEEDED(rv)) {
mListener = converter;
unknownDecoderStarted = true;
}
}
}
}
@@ -1564,32 +1564,31 @@ nsHttpChannel::CallOnStartRequest()
// About to call OnStartRequest, dismiss the guard object.
onStartGuard.release();
if (mListener) {
MOZ_ASSERT(!mOnStartRequestCalled,
"We should not call OsStartRequest twice");
nsCOMPtr<nsIStreamListener> deleteProtector(mListener);
- rv = deleteProtector->OnStartRequest(this, mListenerContext);
+ rv = deleteProtector->OnStartRequest(this, nullptr);
mOnStartRequestCalled = true;
if (NS_FAILED(rv))
return rv;
} else {
NS_WARNING("OnStartRequest skipped because of null listener");
mOnStartRequestCalled = true;
}
// Install stream converter if required.
// If we use unknownDecoder, stream converters will be installed later (in
// nsUnknownDecoder) after OnStartRequest is called for the real listener.
if (!unknownDecoderStarted) {
nsCOMPtr<nsIStreamListener> listener;
- nsISupports *ctxt = mListenerContext;
- rv = DoApplyContentConversions(mListener, getter_AddRefs(listener), ctxt);
+ rv = DoApplyContentConversions(mListener, getter_AddRefs(listener), nullptr);
if (NS_FAILED(rv)) {
return rv;
}
if (listener) {
mListener = listener;
mCompressListener = listener;
}
}
@@ -1965,19 +1964,19 @@ nsHttpChannel::ProcessContentSignatureHe
// verify the signature
if (!aResponseHead->HasContentType()) {
NS_WARNING("Empty content type can get us in trouble when verifying "
"content signatures");
return NS_ERROR_INVALID_SIGNATURE;
}
// create a new listener that meadiates the content
RefPtr<ContentVerifier> contentVerifyingMediator =
- new ContentVerifier(mListener, mListenerContext);
+ new ContentVerifier(mListener, nullptr);
rv = contentVerifyingMediator->Init(contentSignatureHeader, this,
- mListenerContext);
+ nullptr);
NS_ENSURE_SUCCESS(rv, NS_ERROR_INVALID_SIGNATURE);
mListener = contentVerifyingMediator;
return NS_OK;
}
/**
* Decide whether or not to send a security report and, if so, give the
@@ -2928,23 +2927,18 @@ nsHttpChannel::OpenRedirectChannel(nsres
{
AutoRedirectVetoNotifier notifier(this);
// Make sure to do this after we received redirect veto answer,
// i.e. after all sinks had been notified
mRedirectChannel->SetOriginalURI(mOriginalURI);
// open new channel
- if (mLoadInfo && mLoadInfo->GetEnforceSecurity()) {
- MOZ_ASSERT(!mListenerContext, "mListenerContext should be null!");
- rv = mRedirectChannel->AsyncOpen2(mListener);
- }
- else {
- rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);
- }
+ MOZ_ASSERT(mLoadInfo && mLoadInfo->GetEnforceSecurity());
+ rv = mRedirectChannel->AsyncOpen2(mListener);
NS_ENSURE_SUCCESS(rv, rv);
mStatus = NS_BINDING_REDIRECTED;
notifier.RedirectSucceeded();
ReleaseListeners();
@@ -2997,23 +2991,18 @@ nsHttpChannel::ContinueDoReplaceWithProx
NS_PRECONDITION(mRedirectChannel, "No redirect channel?");
// Make sure to do this after we received redirect veto answer,
// i.e. after all sinks had been notified
mRedirectChannel->SetOriginalURI(mOriginalURI);
// open new channel
- if (mLoadInfo && mLoadInfo->GetEnforceSecurity()) {
- MOZ_ASSERT(!mListenerContext, "mListenerContext should be null!");
- rv = mRedirectChannel->AsyncOpen2(mListener);
- }
- else {
- rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);
- }
+ MOZ_ASSERT(mLoadInfo && mLoadInfo->GetEnforceSecurity());
+ rv = mRedirectChannel->AsyncOpen2(mListener);
NS_ENSURE_SUCCESS(rv, rv);
mStatus = NS_BINDING_REDIRECTED;
notifier.RedirectSucceeded();
ReleaseListeners();
@@ -3593,23 +3582,18 @@ nsHttpChannel::ContinueProcessFallback(n
return rv;
NS_PRECONDITION(mRedirectChannel, "No redirect channel?");
// Make sure to do this after we received redirect veto answer,
// i.e. after all sinks had been notified
mRedirectChannel->SetOriginalURI(mOriginalURI);
- if (mLoadInfo && mLoadInfo->GetEnforceSecurity()) {
- MOZ_ASSERT(!mListenerContext, "mListenerContext should be null!");
- rv = mRedirectChannel->AsyncOpen2(mListener);
- }
- else {
- rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);
- }
+ MOZ_ASSERT(mLoadInfo && mLoadInfo->GetEnforceSecurity());
+ rv = mRedirectChannel->AsyncOpen2(mListener);
NS_ENSURE_SUCCESS(rv, rv);
if (mLoadFlags & LOAD_INITIAL_DOCUMENT_URI) {
MaybeWarnAboutAppCache();
}
// close down this channel
Cancel(NS_BINDING_REDIRECTED);
@@ -4995,17 +4979,17 @@ nsHttpChannel::ReadFromCache(bool alread
rv = nsInputStreamPump::Create(getter_AddRefs(mCachePump), inputStream,
0, 0, true);
if (NS_FAILED(rv)) {
inputStream->Close();
return rv;
}
- rv = mCachePump->AsyncRead(this, mListenerContext);
+ rv = mCachePump->AsyncRead(this, nullptr);
if (NS_FAILED(rv)) return rv;
if (mTimingEnabled)
mCacheReadStart = TimeStamp::Now();
uint32_t suspendCount = mSuspendCount;
while (suspendCount--)
mCachePump->Suspend();
@@ -5676,23 +5660,18 @@ nsHttpChannel::ContinueProcessRedirectio
// Make sure to do this after we received redirect veto answer,
// i.e. after all sinks had been notified
mRedirectChannel->SetOriginalURI(mOriginalURI);
// XXX we used to talk directly with the script security manager, but that
// should really be handled by the event sink implementation.
// begin loading the new channel
- if (mLoadInfo && mLoadInfo->GetEnforceSecurity()) {
- MOZ_ASSERT(!mListenerContext, "mListenerContext should be null!");
- rv = mRedirectChannel->AsyncOpen2(mListener);
- }
- else {
- rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);
- }
+ MOZ_ASSERT(mLoadInfo && mLoadInfo->GetEnforceSecurity());
+ rv = mRedirectChannel->AsyncOpen2(mListener);
NS_ENSURE_SUCCESS(rv, rv);
// close down this channel
Cancel(NS_BINDING_REDIRECTED);
notifier.RedirectSucceeded();
ReleaseListeners();
@@ -5942,18 +5921,25 @@ nsHttpChannel::GetSecurityInfo(nsISuppor
}
// If any of the functions that AsyncOpen calls returns immediately an error
// AsyncAbort(which calls onStart/onStopRequest) does not need to be call.
// To be sure that they are not call ReleaseListeners() is called.
// If AsyncOpen returns NS_OK, after that point AsyncAbort must be called on
// any error.
NS_IMETHODIMP
-nsHttpChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *context)
-{
+nsHttpChannel::AsyncOpen2(nsIStreamListener *aListener)
+{
+ nsCOMPtr<nsIStreamListener> listener = aListener;
+ nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ ReleaseListeners();
+ return rv;
+ }
+
MOZ_ASSERT(!mLoadInfo ||
mLoadInfo->GetSecurityMode() == 0 ||
mLoadInfo->GetInitialSecurityCheckDone() ||
(mLoadInfo->GetSecurityMode() == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL &&
nsContentUtils::IsSystemPrincipal(mLoadInfo->LoadingPrincipal())),
"security flags in loadInfo but asyncOpen2() not called");
LOG(("nsHttpChannel::AsyncOpen [this=%p]\n", this));
@@ -5976,18 +5962,16 @@ nsHttpChannel::AsyncOpen(nsIStreamListen
#ifdef DEBUG
AssertPrivateBrowsingId();
#endif
NS_ENSURE_ARG_POINTER(listener);
NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);
NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
- nsresult rv;
-
MOZ_ASSERT(NS_IsMainThread());
if (!gHttpHandler->Active()) {
LOG((" after HTTP shutdown..."));
ReleaseListeners();
return NS_ERROR_NOT_AVAILABLE;
}
@@ -6010,17 +5994,16 @@ nsHttpChannel::AsyncOpen(nsIStreamListen
if (WaitingForTailUnblock()) {
// This channel is marked as Tail and is part of a request context
// that has positive number of non-tailed requestst, hence this channel
// has been put to a queue.
// When tail is unblocked, OnTailUnblock on this channel will be called
// to continue AsyncOpen.
mListener = listener;
- mListenerContext = context;
MOZ_DIAGNOSTIC_ASSERT(!mOnTailUnblock);
mOnTailUnblock = &nsHttpChannel::AsyncOpenOnTailUnblock;
LOG((" put on hold until tail is unblocked"));
return NS_OK;
}
// Remember the cookie header that was set, if any
@@ -6046,17 +6029,16 @@ nsHttpChannel::AsyncOpen(nsIStreamListen
if (!(mLoadFlags & LOAD_REPLACE)) {
gHttpHandler->OnOpeningRequest(this);
}
mIsPending = true;
mWasOpened = true;
mListener = listener;
- mListenerContext = context;
if (mLoadGroup)
mLoadGroup->AddRequest(this, nullptr);
// record asyncopen time unconditionally and clear it if we
// don't want it after OnModifyRequest() weighs in. But waiting for
// that to complete would mean we don't include proxy resolution in the
// timing.
@@ -6082,44 +6064,32 @@ nsHttpChannel::AsyncOpen(nsIStreamListen
}
return NS_OK;
}
nsresult
nsHttpChannel::AsyncOpenOnTailUnblock()
{
- return AsyncOpen(mListener, mListenerContext);
+ return AsyncOpen2(mListener);
}
already_AddRefed<nsChannelClassifier>
nsHttpChannel::GetOrCreateChannelClassifier()
{
if (!mChannelClassifier) {
mChannelClassifier = new nsChannelClassifier(this);
LOG(("nsHttpChannel [%p] created nsChannelClassifier [%p]\n",
this, mChannelClassifier.get()));
}
RefPtr<nsChannelClassifier> classifier = mChannelClassifier;
return classifier.forget();
}
-NS_IMETHODIMP
-nsHttpChannel::AsyncOpen2(nsIStreamListener *aListener)
-{
- nsCOMPtr<nsIStreamListener> listener = aListener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- if (NS_WARN_IF(NS_FAILED(rv))) {
- ReleaseListeners();
- return rv;
- }
- return AsyncOpen(listener, nullptr);
-}
-
// BeginConnect() SHOULD NOT call AsyncAbort(). AsyncAbort will be called by
// functions that called BeginConnect if needed. Only AsyncOpen and
// OnProxyAvailable ever call BeginConnect.
nsresult
nsHttpChannel::BeginConnect()
{
LOG(("nsHttpChannel::BeginConnect [this=%p]\n", this));
nsresult rv;
@@ -7241,17 +7211,17 @@ nsHttpChannel::OnStopRequest(nsIRequest
MOZ_ASSERT(NS_FAILED(status), "should have a failure code here");
// NOTE: since we have a failure status, we can ignore the return
// value from onStartRequest.
LOG((" calling mListener->OnStartRequest [this=%p, listener=%p]\n",
this, mListener.get()));
if (mListener) {
MOZ_ASSERT(!mOnStartRequestCalled,
"We should not call OnStartRequest twice.");
- mListener->OnStartRequest(this, mListenerContext);
+ mListener->OnStartRequest(this, nullptr);
mOnStartRequestCalled = true;
} else {
NS_WARNING("OnStartRequest skipped because of null listener");
}
}
// if this transaction has been replaced, then bail.
if (mTransactionReplaced) {
@@ -7411,17 +7381,17 @@ nsHttpChannel::OnStopRequest(nsIRequest
}
if (mListener) {
LOG(("nsHttpChannel %p calling OnStopRequest\n", this));
MOZ_ASSERT(mOnStartRequestCalled,
"OnStartRequest should be called before OnStopRequest");
MOZ_ASSERT(!mOnStopRequestCalled,
"We should not call OnStopRequest twice");
- mListener->OnStopRequest(this, mListenerContext, status);
+ mListener->OnStopRequest(this, nullptr, status);
mOnStopRequestCalled = true;
}
// notify "http-on-stop-connect" observers
gHttpHandler->OnStopRequest(this);
RemoveAsNonTailRequest();
@@ -7572,17 +7542,17 @@ nsHttpChannel::OnDataAvailable(nsIReques
//
int64_t offsetBefore = 0;
nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(input);
if (seekable && NS_FAILED(seekable->Tell(&offsetBefore))) {
seekable = nullptr;
}
nsresult rv = mListener->OnDataAvailable(this,
- mListenerContext,
+ nullptr,
input,
mLogicalOffset,
count);
if (NS_SUCCEEDED(rv)) {
// by contract mListener must read all of "count" bytes, but
// nsInputStreamPump is tolerant to seekable streams that violate that
// and it will redeliver incompletely read data. So we need to do
// the same thing when updating the progress counter to stay in sync.
--- a/netwerk/protocol/http/nsHttpChannel.h
+++ b/netwerk/protocol/http/nsHttpChannel.h
@@ -151,17 +151,16 @@ public:
// Methods HttpBaseChannel didn't implement for us or that we override.
//
// nsIRequest
NS_IMETHOD Cancel(nsresult status) override;
NS_IMETHOD Suspend() override;
NS_IMETHOD Resume() override;
// nsIChannel
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) override;
- NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext) override;
NS_IMETHOD AsyncOpen2(nsIStreamListener *aListener) override;
// nsIHttpChannel
NS_IMETHOD GetEncodedBodySize(uint64_t *aEncodedBodySize) override;
// nsIHttpChannelInternal
NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey) override;
NS_IMETHOD SetChannelIsForDownload(bool aChannelIsForDownload) override;
// nsISupportsPriority
NS_IMETHOD SetPriority(int32_t value) override;
--- a/netwerk/protocol/res/ExtensionProtocolHandler.cpp
+++ b/netwerk/protocol/res/ExtensionProtocolHandler.cpp
@@ -457,39 +457,35 @@ ExtensionProtocolHandler::SubstituteChan
NS_ENSURE_SUCCESS(rv, rv);
if (!ext.LowerCaseEqualsLiteral("css")) {
return NS_OK;
}
// Filter CSS files to replace locale message tokens with localized strings.
- bool haveLoadInfo = aLoadInfo;
+ MOZ_ASSERT(aLoadInfo);
nsCOMPtr<nsIChannel> channel = NS_NewSimpleChannel(
aURI, aLoadInfo, *result,
- [haveLoadInfo] (nsIStreamListener* listener, nsIChannel* channel, nsIChannel* origChannel) -> RequestOrReason {
+ [] (nsIStreamListener* listener, nsIChannel* channel, nsIChannel* origChannel) -> RequestOrReason {
nsresult rv;
nsCOMPtr<nsIStreamConverterService> convService =
do_GetService(NS_STREAMCONVERTERSERVICE_CONTRACTID, &rv);
MOZ_TRY(rv);
nsCOMPtr<nsIURI> uri;
MOZ_TRY(channel->GetURI(getter_AddRefs(uri)));
const char* kFromType = "application/vnd.mozilla.webext.unlocalized";
const char* kToType = "text/css";
nsCOMPtr<nsIStreamListener> converter;
MOZ_TRY(convService->AsyncConvertData(kFromType, kToType, listener,
uri, getter_AddRefs(converter)));
- if (haveLoadInfo) {
- MOZ_TRY(origChannel->AsyncOpen2(converter));
- } else {
- MOZ_TRY(origChannel->AsyncOpen(converter, nullptr));
- }
+ MOZ_TRY(origChannel->AsyncOpen2(converter));
return RequestOrReason(origChannel);
});
NS_ENSURE_TRUE(channel, NS_ERROR_OUT_OF_MEMORY);
if (aLoadInfo) {
nsCOMPtr<nsILoadInfo> loadInfo =
static_cast<LoadInfo*>(aLoadInfo)->CloneForNewRequest();
--- a/netwerk/protocol/viewsource/nsViewSourceChannel.cpp
+++ b/netwerk/protocol/viewsource/nsViewSourceChannel.cpp
@@ -307,46 +307,51 @@ nsViewSourceChannel::GetURI(nsIURI* *aUR
if (NS_FAILED(rv)) {
return rv;
}
return BuildViewSourceURI(uri, aURI);
}
NS_IMETHODIMP
-nsViewSourceChannel::Open(nsIInputStream **_retval)
-{
- NS_ENSURE_TRUE(mChannel, NS_ERROR_FAILURE);
-
- nsresult rv = NS_MaybeOpenChannelUsingOpen2(mChannel, _retval);
- if (NS_SUCCEEDED(rv)) {
- mOpened = true;
- }
- return rv;
-}
-
-NS_IMETHODIMP
nsViewSourceChannel::Open2(nsIInputStream** aStream)
{
NS_ENSURE_TRUE(mChannel, NS_ERROR_FAILURE);
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
if(!loadInfo) {
MOZ_ASSERT(loadInfo, "can not enforce security without loadInfo");
return NS_ERROR_UNEXPECTED;
}
// setting the flag on the loadInfo indicates that the underlying
// channel will be openend using Open2() and hence performs
// the necessary security checks.
loadInfo->SetEnforceSecurity(true);
- return Open(aStream);
+
+ NS_ENSURE_TRUE(mChannel, NS_ERROR_FAILURE);
+
+ nsresult rv = NS_MaybeOpenChannelUsingOpen2(mChannel, aStream);
+ if (NS_SUCCEEDED(rv)) {
+ mOpened = true;
+ }
+ return rv;
}
NS_IMETHODIMP
-nsViewSourceChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *ctxt)
+nsViewSourceChannel::AsyncOpen2(nsIStreamListener *aListener)
{
+ nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
+ if(!loadInfo) {
+ MOZ_ASSERT(loadInfo, "can not enforce security without loadInfo");
+ return NS_ERROR_UNEXPECTED;
+ }
+ // setting the flag on the loadInfo indicates that the underlying
+ // channel will be openend using AsyncOpen2() and hence performs
+ // the necessary security checks.
+ loadInfo->SetEnforceSecurity(true);
+
#ifdef DEBUG
{
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
MOZ_ASSERT(!loadInfo || loadInfo->GetSecurityMode() == 0 ||
loadInfo->GetEnforceSecurity(),
"security flags in loadInfo but asyncOpen2() not called");
}
#endif
@@ -363,50 +368,31 @@ nsViewSourceChannel::AsyncOpen(nsIStream
nsCOMPtr<nsILoadGroup> loadGroup;
mChannel->GetLoadGroup(getter_AddRefs(loadGroup));
if (loadGroup)
loadGroup->AddRequest(static_cast<nsIViewSourceChannel*>
(this), nullptr);
nsresult rv = NS_OK;
- nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
- if (loadInfo && loadInfo->GetEnforceSecurity()) {
- rv = mChannel->AsyncOpen2(this);
- }
- else {
- rv = mChannel->AsyncOpen(this, ctxt);
- }
+ MOZ_ASSERT(loadInfo && loadInfo->GetEnforceSecurity());
+ rv = mChannel->AsyncOpen2(this);
if (NS_FAILED(rv) && loadGroup)
loadGroup->RemoveRequest(static_cast<nsIViewSourceChannel*>
(this),
nullptr, rv);
if (NS_SUCCEEDED(rv)) {
mOpened = true;
}
return rv;
}
-NS_IMETHODIMP
-nsViewSourceChannel::AsyncOpen2(nsIStreamListener *aListener)
-{
- nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
- if(!loadInfo) {
- MOZ_ASSERT(loadInfo, "can not enforce security without loadInfo");
- return NS_ERROR_UNEXPECTED;
- }
- // setting the flag on the loadInfo indicates that the underlying
- // channel will be openend using AsyncOpen2() and hence performs
- // the necessary security checks.
- loadInfo->SetEnforceSecurity(true);
- return AsyncOpen(aListener, nullptr);
-}
/*
* Both the view source channel and mChannel are added to the
* loadgroup. There should never be more than one request in the
* loadgroup that has LOAD_DOCUMENT_URI set. The one that has this
* flag set is the request whose URI is used to refetch the document,
* so it better be the viewsource channel.
*
* Therefore, we need to make sure that
--- a/netwerk/protocol/wyciwyg/WyciwygChannelChild.cpp
+++ b/netwerk/protocol/wyciwyg/WyciwygChannelChild.cpp
@@ -202,17 +202,17 @@ WyciwygChannelChild::OnStartRequest(cons
mCharset = charset;
if (!securityInfo.IsEmpty()) {
NS_DeserializeObject(securityInfo, getter_AddRefs(mSecurityInfo));
}
AutoEventEnqueuer ensureSerialDispatch(mEventQ);
- nsresult rv = mListener->OnStartRequest(this, mListenerContext);
+ nsresult rv = mListener->OnStartRequest(this, nullptr);
if (NS_FAILED(rv))
Cancel(rv);
}
class WyciwygDataAvailableEvent
: public NeckoTargetChannelEvent<WyciwygChannelChild>
{
public:
@@ -261,17 +261,17 @@ WyciwygChannelChild::OnDataAvailable(con
NS_ASSIGNMENT_DEPEND);
if (NS_FAILED(rv)) {
Cancel(rv);
return;
}
AutoEventEnqueuer ensureSerialDispatch(mEventQ);
- rv = mListener->OnDataAvailable(this, mListenerContext,
+ rv = mListener->OnDataAvailable(this, nullptr,
stringStream, offset, data.Length());
if (NS_FAILED(rv))
Cancel(rv);
if (mProgressSink && NS_SUCCEEDED(rv)) {
mProgressSink->OnProgress(this, nullptr, offset + data.Length(),
mContentLength);
}
@@ -311,20 +311,19 @@ WyciwygChannelChild::OnStopRequest(const
mState = WCC_ONSTOP;
mIsPending = false;
if (!mCanceled)
mStatus = statusCode;
- mListener->OnStopRequest(this, mListenerContext, statusCode);
+ mListener->OnStopRequest(this, nullptr, statusCode);
mListener = nullptr;
- mListenerContext = nullptr;
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nullptr, mStatus);
mCallbacks = nullptr;
mProgressSink = nullptr;
}
@@ -362,21 +361,20 @@ void WyciwygChannelChild::CancelEarly(co
mCanceled = true;
mStatus = statusCode;
mIsPending = false;
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nullptr, mStatus);
if (mListener) {
- mListener->OnStartRequest(this, mListenerContext);
- mListener->OnStopRequest(this, mListenerContext, mStatus);
+ mListener->OnStartRequest(this, nullptr);
+ mListener->OnStopRequest(this, nullptr, mStatus);
}
mListener = nullptr;
- mListenerContext = nullptr;
if (mIPCOpen)
PWyciwygChannelChild::Send__delete__(this);
}
//-----------------------------------------------------------------------------
// nsIRequest
//-----------------------------------------------------------------------------
@@ -618,61 +616,58 @@ WyciwygChannelChild::GetContentLength(in
}
NS_IMETHODIMP
WyciwygChannelChild::SetContentLength(int64_t aContentLength)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
-WyciwygChannelChild::Open(nsIInputStream **_retval)
+WyciwygChannelChild::Open2(nsIInputStream** aStream)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
-NS_IMETHODIMP
-WyciwygChannelChild::Open2(nsIInputStream** aStream)
-{
- nsCOMPtr<nsIStreamListener> listener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- NS_ENSURE_SUCCESS(rv, rv);
- return Open(aStream);
-}
-
static mozilla::dom::TabChild*
GetTabChild(nsIChannel* aChannel)
{
nsCOMPtr<nsITabChild> iTabChild;
NS_QueryNotificationCallbacks(aChannel, iTabChild);
return iTabChild ? static_cast<mozilla::dom::TabChild*>(iTabChild.get()) : nullptr;
}
NS_IMETHODIMP
-WyciwygChannelChild::AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext)
+WyciwygChannelChild::AsyncOpen2(nsIStreamListener *aListener)
{
+ nsCOMPtr<nsIStreamListener> listener = aListener;
+ nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+ if (NS_FAILED(rv)) {
+ mCallbacks = nullptr;
+ return rv;
+ }
+
MOZ_ASSERT(!mLoadInfo ||
mLoadInfo->GetSecurityMode() == 0 ||
mLoadInfo->GetInitialSecurityCheckDone() ||
(mLoadInfo->GetSecurityMode() == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL &&
nsContentUtils::IsSystemPrincipal(mLoadInfo->LoadingPrincipal())),
"security flags in loadInfo but asyncOpen2() not called");
LOG(("WyciwygChannelChild::AsyncOpen [this=%p]\n", this));
// The only places creating wyciwyg: channels should be
// HTMLDocument::OpenCommon and session history. Both should be setting an
// owner or loadinfo.
NS_PRECONDITION(mOwner || mLoadInfo, "Must have a principal");
NS_ENSURE_STATE(mOwner || mLoadInfo);
- NS_ENSURE_ARG_POINTER(aListener);
+ NS_ENSURE_ARG_POINTER(listener);
NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);
- mListener = aListener;
- mListenerContext = aContext;
+ mListener = listener;
mIsPending = true;
if (mLoadGroup) {
mLoadGroup->AddRequest(this, nullptr);
}
URIParams originalURI;
SerializeURI(mOriginalURI, originalURI);
@@ -689,28 +684,16 @@ WyciwygChannelChild::AsyncOpen(nsIStream
SendAsyncOpen(originalURI, mLoadFlags, IPC::SerializedLoadContext(this), browser);
mSentAppData = true;
mState = WCC_OPENED;
return NS_OK;
}
-NS_IMETHODIMP
-WyciwygChannelChild::AsyncOpen2(nsIStreamListener *aListener)
-{
- nsCOMPtr<nsIStreamListener> listener = aListener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- if (NS_FAILED(rv)) {
- mCallbacks = nullptr;
- return rv;
- }
- return AsyncOpen(listener, nullptr);
-}
-
//-----------------------------------------------------------------------------
// nsIWyciwygChannel
//-----------------------------------------------------------------------------
NS_IMETHODIMP
WyciwygChannelChild::WriteToCacheEntry(const nsAString & aData)
{
NS_ENSURE_TRUE((mState == WCC_INIT) ||
--- a/netwerk/protocol/wyciwyg/WyciwygChannelChild.h
+++ b/netwerk/protocol/wyciwyg/WyciwygChannelChild.h
@@ -93,17 +93,16 @@ private:
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsIURI> mOriginalURI;
nsCOMPtr<nsISupports> mOwner;
nsCOMPtr<nsILoadInfo> mLoadInfo;
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsIProgressEventSink> mProgressSink;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsIStreamListener> mListener;
- nsCOMPtr<nsISupports> mListenerContext;
nsCOMPtr<nsISupports> mSecurityInfo;
// FIXME: replace with IPDL states (bug 536319)
enum WyciwygChannelChildState mState;
bool mIPCOpen;
bool mSentAppData;
RefPtr<ChannelEventQueue> mEventQ;
--- a/netwerk/protocol/wyciwyg/WyciwygChannelParent.cpp
+++ b/netwerk/protocol/wyciwyg/WyciwygChannelParent.cpp
@@ -237,24 +237,17 @@ WyciwygChannelParent::RecvAsyncOpen(cons
rv = mChannel->SetNotificationCallbacks(this);
if (NS_FAILED(rv)) {
if (!SendCancelEarly(rv)) {
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();
}
- nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
- if (loadInfo && loadInfo->GetEnforceSecurity()) {
- rv = mChannel->AsyncOpen2(this);
- }
- else {
- rv = mChannel->AsyncOpen(this, nullptr);
- }
-
+ rv = mChannel->AsyncOpen2(this);
if (NS_FAILED(rv)) {
if (!SendCancelEarly(rv)) {
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();
}
return IPC_OK();
--- a/netwerk/protocol/wyciwyg/nsWyciwygChannel.cpp
+++ b/netwerk/protocol/wyciwyg/nsWyciwygChannel.cpp
@@ -331,33 +331,32 @@ NS_IMETHODIMP
nsWyciwygChannel::SetContentLength(int64_t aContentLength)
{
mContentLength = aContentLength;
return NS_OK;
}
NS_IMETHODIMP
-nsWyciwygChannel::Open(nsIInputStream ** aReturn)
+nsWyciwygChannel::Open2(nsIInputStream** aStream)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
-nsWyciwygChannel::Open2(nsIInputStream** aStream)
+nsWyciwygChannel::AsyncOpen2(nsIStreamListener *aListener)
{
- nsCOMPtr<nsIStreamListener> listener;
+ nsCOMPtr<nsIStreamListener> listener = aListener;
nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- NS_ENSURE_SUCCESS(rv, rv);
- return Open(aStream);
-}
+ if (NS_FAILED(rv)) {
+ mIsPending = false;
+ mCallbacks = nullptr;
+ return rv;
+ }
-NS_IMETHODIMP
-nsWyciwygChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctx)
-{
MOZ_ASSERT(!mLoadInfo ||
mLoadInfo->GetSecurityMode() == 0 ||
mLoadInfo->GetInitialSecurityCheckDone() ||
(mLoadInfo->GetSecurityMode() == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL &&
nsContentUtils::IsSystemPrincipal(mLoadInfo->LoadingPrincipal())),
"security flags in loadInfo but asyncOpen2() not called");
LOG(("nsWyciwygChannel::AsyncOpen [this=%p]\n", this));
@@ -368,50 +367,36 @@ nsWyciwygChannel::AsyncOpen(nsIStreamLis
NS_ENSURE_ARG_POINTER(listener);
mMode = READING;
// open a cache entry for this channel...
// mIsPending set to true since OnCacheEntryAvailable may be called
// synchronously and fails when mIsPending found false.
mIsPending = true;
- nsresult rv = OpenCacheEntryForReading(mURI);
+ rv = OpenCacheEntryForReading(mURI);
if (NS_FAILED(rv)) {
LOG(("nsWyciwygChannel::OpenCacheEntryForReading failed [rv=%" PRIx32 "]\n",
static_cast<uint32_t>(rv)));
mIsPending = false;
mCallbacks = nullptr;
return rv;
}
// There is no code path that would invoke the listener sooner than
// we get to this line in case OnCacheEntryAvailable is invoked
// synchronously.
mListener = listener;
- mListenerContext = ctx;
if (mLoadGroup)
mLoadGroup->AddRequest(this, nullptr);
return NS_OK;
}
-NS_IMETHODIMP
-nsWyciwygChannel::AsyncOpen2(nsIStreamListener *aListener)
-{
- nsCOMPtr<nsIStreamListener> listener = aListener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- if (NS_FAILED(rv)) {
- mIsPending = false;
- mCallbacks = nullptr;
- return rv;
- }
- return AsyncOpen(listener, nullptr);
-}
-
//////////////////////////////////////////////////////////////////////////////
// nsIWyciwygChannel
//////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsWyciwygChannel::WriteToCacheEntry(const nsAString &aData)
{
LOG(("nsWyciwygChannel::WriteToCacheEntry [this=%p]", this));
@@ -619,20 +604,19 @@ nsWyciwygChannel::OnDataAvailable(nsIReq
uint64_t offset, uint32_t count)
{
LOG(("nsWyciwygChannel::OnDataAvailable [this=%p request=%p offset=%" PRIu64 " count=%u]\n",
this, request, offset, count));
nsresult rv;
nsCOMPtr<nsIStreamListener> listener = mListener;
- nsCOMPtr<nsISupports> listenerContext = mListenerContext;
if (listener) {
- rv = listener->OnDataAvailable(this, listenerContext, input, offset, count);
+ rv = listener->OnDataAvailable(this, nullptr, input, offset, count);
} else {
MOZ_ASSERT(false, "We must have a listener!");
rv = NS_ERROR_UNEXPECTED;
}
// XXX handle 64-bit stuff for real
if (mProgressSink && NS_SUCCEEDED(rv)) {
mProgressSink->OnProgress(this, nullptr, offset + count, mContentLength);
@@ -647,20 +631,19 @@ nsWyciwygChannel::OnDataAvailable(nsIReq
NS_IMETHODIMP
nsWyciwygChannel::OnStartRequest(nsIRequest *request, nsISupports *ctx)
{
LOG(("nsWyciwygChannel::OnStartRequest [this=%p request=%p]\n",
this, request));
nsCOMPtr<nsIStreamListener> listener = mListener;
- nsCOMPtr<nsISupports> listenerContext = mListenerContext;
if (listener) {
- return listener->OnStartRequest(this, listenerContext);
+ return listener->OnStartRequest(this, nullptr);
}
MOZ_ASSERT(false, "We must have a listener!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
@@ -670,22 +653,20 @@ nsWyciwygChannel::OnStopRequest(nsIReque
this, request, static_cast<uint32_t>(status)));
if (NS_SUCCEEDED(mStatus))
mStatus = status;
mIsPending = false;
nsCOMPtr<nsIStreamListener> listener;
- nsCOMPtr<nsISupports> listenerContext;
listener.swap(mListener);
- listenerContext.swap(mListenerContext);
if (listener) {
- listener->OnStopRequest(this, listenerContext, mStatus);
+ listener->OnStopRequest(this, nullptr, mStatus);
} else {
MOZ_ASSERT(false, "We must have a listener!");
}
if (mLoadGroup)
mLoadGroup->RemoveRequest(this, nullptr, mStatus);
CloseCacheEntry(mStatus);
@@ -793,25 +774,23 @@ nsWyciwygChannel::WriteCharsetAndSourceT
source.AppendInt(aSource);
mCacheEntry->SetMetaDataElement("charset-source", source.get());
}
void
nsWyciwygChannel::NotifyListener()
{
nsCOMPtr<nsIStreamListener> listener;
- nsCOMPtr<nsISupports> listenerContext;
listener.swap(mListener);
- listenerContext.swap(mListenerContext);
if (listener) {
- listener->OnStartRequest(this, listenerContext);
+ listener->OnStartRequest(this, nullptr);
mIsPending = false;
- listener->OnStopRequest(this, listenerContext, mStatus);
+ listener->OnStopRequest(this, nullptr, mStatus);
} else {
MOZ_ASSERT(false, "We must have the listener!");
mIsPending = false;
}
CloseCacheEntry(mStatus);
// Remove ourselves from the load group.
--- a/netwerk/protocol/wyciwyg/nsWyciwygChannel.h
+++ b/netwerk/protocol/wyciwyg/nsWyciwygChannel.h
@@ -83,17 +83,16 @@ protected:
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsIURI> mOriginalURI;
nsCOMPtr<nsISupports> mOwner;
nsCOMPtr<nsILoadInfo> mLoadInfo;
nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
nsCOMPtr<nsIProgressEventSink> mProgressSink;
nsCOMPtr<nsILoadGroup> mLoadGroup;
nsCOMPtr<nsIStreamListener> mListener;
- nsCOMPtr<nsISupports> mListenerContext;
// reuse as much of this channel implementation as we can
nsCOMPtr<nsIInputStreamPump> mPump;
// Cache related stuff
nsCOMPtr<nsICacheEntry> mCacheEntry;
nsCOMPtr<nsIOutputStream> mCacheOutputStream;
--- a/netwerk/streamconv/converters/nsMultiMixedConv.cpp
+++ b/netwerk/streamconv/converters/nsMultiMixedConv.cpp
@@ -177,45 +177,27 @@ nsPartChannel::SetOriginalURI(nsIURI *aU
NS_IMETHODIMP
nsPartChannel::GetURI(nsIURI * *aURI)
{
return mMultipartChannel->GetURI(aURI);
}
NS_IMETHODIMP
-nsPartChannel::Open(nsIInputStream **result)
-{
- // This channel cannot be opened!
- return NS_ERROR_FAILURE;
-}
-
-NS_IMETHODIMP
nsPartChannel::Open2(nsIInputStream** aStream)
{
- nsCOMPtr<nsIStreamListener> listener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- NS_ENSURE_SUCCESS(rv, rv);
- return Open(aStream);
-}
-
-NS_IMETHODIMP
-nsPartChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext)
-{
// This channel cannot be opened!
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsPartChannel::AsyncOpen2(nsIStreamListener *aListener)
{
- nsCOMPtr<nsIStreamListener> listener = aListener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- NS_ENSURE_SUCCESS(rv, rv);
- return AsyncOpen(listener, nullptr);
+ // This channel cannot be opened!
+ return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsPartChannel::GetLoadFlags(nsLoadFlags *aLoadFlags)
{
*aLoadFlags = mLoadFlags;
return NS_OK;
}
--- a/netwerk/test/browser/browser_nsIFormPOSTActionChannel.js
+++ b/netwerk/test/browser/browser_nsIFormPOSTActionChannel.js
@@ -108,23 +108,20 @@ CustomChannel.prototype = {
},
contentCharset: "UTF-8",
get contentLength() {
return -1;
},
set contentLength(val) {
throw Cr.NS_ERROR_NOT_IMPLEMENTED;
},
- open: function() {
- throw Cr.NS_ERROR_NOT_IMPLEMENTED;
- },
open2: function() {
throw Cr.NS_ERROR_NOT_IMPLEMENTED;
},
- asyncOpen: function(aListener, aContext) {
+ asyncOpen2: function(aListener) {
var data = `
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>test bug 1241377</title>
</head>
<body>
@@ -175,31 +172,28 @@ document.getElementById('form').submit()
var stream = Cc["@mozilla.org/io/string-input-stream;1"]
.createInstance(Ci.nsIStringInputStream);
stream.setData(data, data.length);
var runnable = {
run: () => {
try {
- aListener.onStartRequest(this, aContext);
+ aListener.onStartRequest(this, null);
} catch(e) {}
try {
- aListener.onDataAvailable(this, aContext, stream, 0, stream.available());
+ aListener.onDataAvailable(this, null, stream, 0, stream.available());
} catch(e) {}
try {
- aListener.onStopRequest(this, aContext, Cr.NS_OK);
+ aListener.onStopRequest(this, null, Cr.NS_OK);
} catch(e) {}
}
};
Services.tm.dispatchToMainThread(runnable);
},
- asyncOpen2: function(aListener) {
- this.asyncOpen(aListener, null);
- },
/** nsIRequest */
get name() {
return this.uri.spec;
},
isPending: function () {
return false;
},
deleted file mode 100644
--- a/netwerk/test/unit/test_1351443-missing-NewChannel2.js
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Tests for bug 1351443: NewChannel2 should only fallback to NewChannel if
- * NewChannel2() is unimplemented.
- */
-
-"use strict";
-
-ChromeUtils.import("resource://gre/modules/Services.jsm");
-ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
-ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
-
-var contentSecManager = Cc["@mozilla.org/contentsecuritymanager;1"]
- .getService(Ci.nsIContentSecurityManager);
-
-function ProtocolHandler() {
- this.uri = Cc["@mozilla.org/network/simple-uri-mutator;1"]
- .createInstance(Ci.nsIURIMutator)
- .setSpec(this.scheme + ":dummy")
- .finalize();
- this.uri.QueryInterface(Ci.nsIMutable).mutable = false;
-}
-
-ProtocolHandler.prototype = {
- /** nsIProtocolHandler */
- get scheme() {
- return "x-1351443";
- },
- get defaultPort() {
- return -1;
- },
- get protocolFlags() {
- return Ci.nsIProtocolHandler.URI_NORELATIVE |
- Ci.nsIProtocolHandler.URI_NOAUTH |
- Ci.nsIProtocolHandler.URI_IS_UI_RESOURCE |
- Ci.nsIProtocolHandler.URI_IS_LOCAL_RESOURCE |
- Ci.nsIProtocolHandler.URI_NON_PERSISTABLE |
- Ci.nsIProtocolHandler.URI_SYNC_LOAD_IS_OK;
- },
- newURI: function(aSpec, aOriginCharset, aBaseURI) {
- return this.uri;
- },
- newChannel2: function(aURI, aLoadInfo) {
- this.loadInfo = aLoadInfo;
- return this;
- },
- newChannel2_not_implemented: function(aURI, aLoadInfo) {
- throw Cr.NS_ERROR_NOT_IMPLEMENTED;
- },
- newChannel2_failure: function(aURI, aLoadInfo) {
- throw Cr.NS_ERROR_FAILURE;
- },
- newChannel: function(aURI) {
- return this;
- },
- allowPort: function(port, scheme) {
- return port != -1;
- },
-
- /** nsIChannel */
- get originalURI() {
- return this.uri;
- },
- get URI() {
- return this.uri;
- },
- owner: null,
- notificationCallbacks: null,
- get securityInfo() {
- return null;
- },
- get contentType() {
- return "text/css";
- },
- set contentType(val) {
- },
- contentCharset: "UTF-8",
- get contentLength() {
- return -1;
- },
- set contentLength(val) {
- throw Components.Exception("Setting content length", NS_ERROR_NOT_IMPLEMENTED);
- },
- open: function() {
- var file = do_get_file("test_bug894586.js", false);
- Assert.ok(file.exists());
- var url = Services.io.newFileURI(file);
- return NetUtil.newChannel({uri: url, loadUsingSystemPrincipal: true}).open2();
- },
- open2: function() {
- // throws an error if security checks fail
- contentSecManager.performSecurityCheck(this, null);
- return this.open();
- },
- asyncOpen: function(aListener, aContext) {
- throw Components.Exception("Not implemented",
- Cr.NS_ERROR_NOT_IMPLEMENTED);
- },
- asyncOpen2: function(aListener, aContext) {
- throw Components.Exception("Not implemented",
- Cr.NS_ERROR_NOT_IMPLEMENTED);
- },
- contentDisposition: Ci.nsIChannel.DISPOSITION_INLINE,
- get contentDispositionFilename() {
- throw Components.Exception("No file name",
- Cr.NS_ERROR_NOT_AVAILABLE);
- },
- get contentDispositionHeader() {
- throw Components.Exception("No header",
- Cr.NS_ERROR_NOT_AVAILABLE);
- },
-
- /** nsIRequest */
- get name() {
- return this.uri.spec;
- },
- isPending: () => false,
- get status() {
- return Cr.NS_OK;
- },
- cancel: function(status) {},
- loadGroup: null,
- loadFlags: Ci.nsIRequest.LOAD_NORMAL |
- Ci.nsIRequest.INHIBIT_CACHING |
- Ci.nsIRequest.LOAD_BYPASS_CACHE,
-
- /** nsIFactory */
- createInstance: function(aOuter, aIID) {
- if (aOuter) {
- throw Components.Exception("createInstance no aggregation",
- Cr.NS_ERROR_NO_AGGREGATION);
- }
- return this.QueryInterface(aIID);
- },
- lockFactory: function() {},
-
- /** nsISupports */
- QueryInterface: XPCOMUtils.generateQI([Ci.nsIProtocolHandler,
- Ci.nsIRequest,
- Ci.nsIChannel,
- Ci.nsIFactory]),
- classID: Components.ID("{accbaf4a-2fd9-47e7-8aad-8c19fc5265b5}")
-};
-
-/**
- * Attempt a sync load; we use the stylesheet service to do this for us,
- * based on the knowledge that it forces a sync load under the hood.
- */
-function run_test()
-{
- var handler = new ProtocolHandler();
- var registrar = Components.manager.
- QueryInterface(Ci.nsIComponentRegistrar);
- registrar.registerFactory(handler.classID, "",
- "@mozilla.org/network/protocol;1?name=" + handler.scheme,
- handler);
-
- // The default implementation of NewChannel2 should work.
- var channel = NetUtil.newChannel({
- uri: handler.uri,
- loadUsingSystemPrincipal: true
- });
- ok(channel, "channel exists");
- channel = null;
-
- // If the method throws NS_ERROR_NOT_IMPLEMENTED, it should fall back on newChannel()
- handler.newChannel2 = handler.newChannel2_not_implemented;
- channel = NetUtil.newChannel({
- uri: handler.uri,
- loadUsingSystemPrincipal: true
- });
- ok(channel, "channel exists");
- channel = null;
-
- // If the method is not defined (the error code will be
- // NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED) it should fall back on newChannel()
- handler.newChannel2 = undefined;
- channel = NetUtil.newChannel({
- uri: handler.uri,
- loadUsingSystemPrincipal: true
- });
- ok(channel, "channel exists");
- channel = null;
-
- // If the method simply throws an error code, it should not fall back on newChannel()
- // so we make sure it throws.
- handler.newChannel2 = handler.newChannel2_failure;
- Assert.throws(() => {
- channel = NetUtil.newChannel({
- uri: handler.uri,
- loadUsingSystemPrincipal: true
- });
- }, /Failure/, "If the channel returns an error code, it should throw");
- ok(!channel, "channel should not exist");
-}
--- a/netwerk/test/unit/xpcshell.ini
+++ b/netwerk/test/unit/xpcshell.ini
@@ -399,17 +399,16 @@ skip-if = os == "android"
[test_throttlequeue.js]
[test_throttlechannel.js]
[test_throttling.js]
[test_separate_connections.js]
[test_trackingProtection_annotateChannels.js]
[test_race_cache_with_network.js]
[test_channel_priority.js]
[test_bug1312774_http1.js]
-[test_1351443-missing-NewChannel2.js]
[test_bug1312782_http1.js]
[test_bug1355539_http1.js]
[test_bug1378385_http1.js]
[test_tls_flags_separate_connections.js]
[test_tls_flags.js]
[test_uri_mutator.js]
[test_bug1411316_http1.js]
[test_header_Server_Timing.js]
--- a/uriloader/exthandler/ExternalHelperAppParent.cpp
+++ b/uriloader/exthandler/ExternalHelperAppParent.cpp
@@ -306,35 +306,22 @@ ExternalHelperAppParent::SetOriginalURI(
NS_IMETHODIMP
ExternalHelperAppParent::GetURI(nsIURI **aURI)
{
NS_IF_ADDREF(*aURI = mURI);
return NS_OK;
}
NS_IMETHODIMP
-ExternalHelperAppParent::Open(nsIInputStream **aResult)
-{
- return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP
ExternalHelperAppParent::Open2(nsIInputStream** aStream)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
-ExternalHelperAppParent::AsyncOpen(nsIStreamListener *aListener,
- nsISupports *aContext)
-{
- return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP
ExternalHelperAppParent::AsyncOpen2(nsIStreamListener *aListener)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
ExternalHelperAppParent::GetLoadFlags(nsLoadFlags *aLoadFlags)
--- a/uriloader/exthandler/nsExternalProtocolHandler.cpp
+++ b/uriloader/exthandler/nsExternalProtocolHandler.cpp
@@ -194,31 +194,33 @@ nsresult nsExtProtocolChannel::OpenURL()
}
finish:
mCallbacks = nullptr;
mListener = nullptr;
return rv;
}
-NS_IMETHODIMP nsExtProtocolChannel::Open(nsIInputStream **_retval)
-{
- return OpenURL();
-}
-
NS_IMETHODIMP nsExtProtocolChannel::Open2(nsIInputStream** aStream)
{
nsCOMPtr<nsIStreamListener> listener;
nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
NS_ENSURE_SUCCESS(rv, rv);
- return Open(aStream);
+ return OpenURL();
}
-NS_IMETHODIMP nsExtProtocolChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt)
+NS_IMETHODIMP nsExtProtocolChannel::AsyncOpen2(nsIStreamListener *aListener)
{
+ nsCOMPtr<nsIStreamListener> listener = aListener;
+ nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+ if (NS_FAILED(rv)) {
+ mCallbacks = nullptr;
+ return rv;
+ }
+
if (mConnectedParent) {
return NS_OK;
}
MOZ_ASSERT(!mLoadInfo ||
mLoadInfo->GetSecurityMode() == 0 ||
mLoadInfo->GetInitialSecurityCheckDone() ||
(mLoadInfo->GetSecurityMode() == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL &&
@@ -229,27 +231,16 @@ NS_IMETHODIMP nsExtProtocolChannel::Asyn
NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
mWasOpened = true;
mListener = listener;
return OpenURL();
}
-NS_IMETHODIMP nsExtProtocolChannel::AsyncOpen2(nsIStreamListener *aListener)
-{
- nsCOMPtr<nsIStreamListener> listener = aListener;
- nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
- if (NS_FAILED(rv)) {
- mCallbacks = nullptr;
- return rv;
- }
- return AsyncOpen(listener, nullptr);
-}
-
NS_IMETHODIMP nsExtProtocolChannel::GetLoadFlags(nsLoadFlags *aLoadFlags)
{
*aLoadFlags = mLoadFlags;
return NS_OK;
}
NS_IMETHODIMP nsExtProtocolChannel::SetLoadFlags(nsLoadFlags aLoadFlags)
{
@@ -393,17 +384,17 @@ NS_IMETHODIMP nsExtProtocolChannel::Conn
}
NS_IMETHODIMP nsExtProtocolChannel::CompleteRedirectSetup(nsIStreamListener *listener,
nsISupports *context)
{
// For redirects to external protocols we AsyncOpen on the child
// (not the parent) because child channel has the right docshell
// (which is needed for the select dialog).
- return AsyncOpen(listener, context);
+ return AsyncOpen2(listener);
}
///////////////////////////////////////////////////////////////////////
// From nsIParentChannel (derives from nsIStreamListener)
//////////////////////////////////////////////////////////////////////
NS_IMETHODIMP nsExtProtocolChannel::SetParentListener(HttpChannelParentListener* aListener)
{