summaryrefslogtreecommitdiffstats
path: root/netwerk/base/nsAsyncRedirectVerifyHelper.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /netwerk/base/nsAsyncRedirectVerifyHelper.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'netwerk/base/nsAsyncRedirectVerifyHelper.cpp')
-rw-r--r--netwerk/base/nsAsyncRedirectVerifyHelper.cpp288
1 files changed, 288 insertions, 0 deletions
diff --git a/netwerk/base/nsAsyncRedirectVerifyHelper.cpp b/netwerk/base/nsAsyncRedirectVerifyHelper.cpp
new file mode 100644
index 000000000..3b19b93c7
--- /dev/null
+++ b/netwerk/base/nsAsyncRedirectVerifyHelper.cpp
@@ -0,0 +1,288 @@
+/* -*- Mode: C++; tab-width: 4; 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 "mozilla/Logging.h"
+#include "nsAsyncRedirectVerifyHelper.h"
+#include "nsThreadUtils.h"
+#include "nsNetUtil.h"
+
+#include "nsIOService.h"
+#include "nsIChannel.h"
+#include "nsIHttpChannelInternal.h"
+#include "nsIAsyncVerifyRedirectCallback.h"
+#include "nsILoadInfo.h"
+
+namespace mozilla {
+namespace net {
+
+static LazyLogModule gRedirectLog("nsRedirect");
+#undef LOG
+#define LOG(args) MOZ_LOG(gRedirectLog, LogLevel::Debug, args)
+
+NS_IMPL_ISUPPORTS(nsAsyncRedirectVerifyHelper,
+ nsIAsyncVerifyRedirectCallback,
+ nsIRunnable)
+
+class nsAsyncVerifyRedirectCallbackEvent : public Runnable {
+public:
+ nsAsyncVerifyRedirectCallbackEvent(nsIAsyncVerifyRedirectCallback *cb,
+ nsresult result)
+ : mCallback(cb), mResult(result) {
+ }
+
+ NS_IMETHOD Run() override
+ {
+ LOG(("nsAsyncVerifyRedirectCallbackEvent::Run() "
+ "callback to %p with result %x",
+ mCallback.get(), mResult));
+ (void) mCallback->OnRedirectVerifyCallback(mResult);
+ return NS_OK;
+ }
+private:
+ nsCOMPtr<nsIAsyncVerifyRedirectCallback> mCallback;
+ nsresult mResult;
+};
+
+nsAsyncRedirectVerifyHelper::nsAsyncRedirectVerifyHelper()
+ : mFlags(0),
+ mWaitingForRedirectCallback(false),
+ mCallbackInitiated(false),
+ mExpectedCallbacks(0),
+ mResult(NS_OK)
+{
+}
+
+nsAsyncRedirectVerifyHelper::~nsAsyncRedirectVerifyHelper()
+{
+ NS_ASSERTION(NS_FAILED(mResult) || mExpectedCallbacks == 0,
+ "Did not receive all required callbacks!");
+}
+
+nsresult
+nsAsyncRedirectVerifyHelper::Init(nsIChannel* oldChan, nsIChannel* newChan,
+ uint32_t flags, bool synchronize)
+{
+ LOG(("nsAsyncRedirectVerifyHelper::Init() "
+ "oldChan=%p newChan=%p", oldChan, newChan));
+ mOldChan = oldChan;
+ mNewChan = newChan;
+ mFlags = flags;
+ mCallbackThread = do_GetCurrentThread();
+
+ if (!(flags & (nsIChannelEventSink::REDIRECT_INTERNAL |
+ nsIChannelEventSink::REDIRECT_STS_UPGRADE))) {
+ nsCOMPtr<nsILoadInfo> loadInfo = oldChan->GetLoadInfo();
+ if (loadInfo && loadInfo->GetDontFollowRedirects()) {
+ ExplicitCallback(NS_BINDING_ABORTED);
+ return NS_OK;
+ }
+ }
+
+ if (synchronize)
+ mWaitingForRedirectCallback = true;
+
+ nsresult rv;
+ rv = NS_DispatchToMainThread(this);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (synchronize) {
+ nsIThread *thread = NS_GetCurrentThread();
+ while (mWaitingForRedirectCallback) {
+ if (!NS_ProcessNextEvent(thread)) {
+ return NS_ERROR_UNEXPECTED;
+ }
+ }
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAsyncRedirectVerifyHelper::OnRedirectVerifyCallback(nsresult result)
+{
+ LOG(("nsAsyncRedirectVerifyHelper::OnRedirectVerifyCallback() "
+ "result=%x expectedCBs=%u mResult=%x",
+ result, mExpectedCallbacks, mResult));
+
+ MOZ_DIAGNOSTIC_ASSERT(mExpectedCallbacks > 0,
+ "OnRedirectVerifyCallback called more times than expected");
+ if (mExpectedCallbacks <= 0) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ --mExpectedCallbacks;
+
+ // If response indicates failure we may call back immediately
+ if (NS_FAILED(result)) {
+ // We chose to store the first failure-value (as opposed to the last)
+ if (NS_SUCCEEDED(mResult))
+ mResult = result;
+
+ // If InitCallback() has been called, just invoke the callback and
+ // return. Otherwise it will be invoked from InitCallback()
+ if (mCallbackInitiated) {
+ ExplicitCallback(mResult);
+ return NS_OK;
+ }
+ }
+
+ // If the expected-counter is in balance and InitCallback() was called, all
+ // sinks have agreed that the redirect is ok and we can invoke our callback
+ if (mCallbackInitiated && mExpectedCallbacks == 0) {
+ ExplicitCallback(mResult);
+ }
+
+ return NS_OK;
+}
+
+nsresult
+nsAsyncRedirectVerifyHelper::DelegateOnChannelRedirect(nsIChannelEventSink *sink,
+ nsIChannel *oldChannel,
+ nsIChannel *newChannel,
+ uint32_t flags)
+{
+ LOG(("nsAsyncRedirectVerifyHelper::DelegateOnChannelRedirect() "
+ "sink=%p expectedCBs=%u mResult=%x",
+ sink, mExpectedCallbacks, mResult));
+
+ ++mExpectedCallbacks;
+
+ if (IsOldChannelCanceled()) {
+ LOG((" old channel has been canceled, cancel the redirect by "
+ "emulating OnRedirectVerifyCallback..."));
+ (void) OnRedirectVerifyCallback(NS_BINDING_ABORTED);
+ return NS_BINDING_ABORTED;
+ }
+
+ nsresult rv =
+ sink->AsyncOnChannelRedirect(oldChannel, newChannel, flags, this);
+
+ LOG((" result=%x expectedCBs=%u", rv, mExpectedCallbacks));
+
+ // If the sink returns failure from this call the redirect is vetoed. We
+ // emulate a callback from the sink in this case in order to perform all
+ // the necessary logic.
+ if (NS_FAILED(rv)) {
+ LOG((" emulating OnRedirectVerifyCallback..."));
+ (void) OnRedirectVerifyCallback(rv);
+ }
+
+ return rv; // Return the actual status since our caller may need it
+}
+
+void
+nsAsyncRedirectVerifyHelper::ExplicitCallback(nsresult result)
+{
+ LOG(("nsAsyncRedirectVerifyHelper::ExplicitCallback() "
+ "result=%x expectedCBs=%u mCallbackInitiated=%u mResult=%x",
+ result, mExpectedCallbacks, mCallbackInitiated, mResult));
+
+ nsCOMPtr<nsIAsyncVerifyRedirectCallback>
+ callback(do_QueryInterface(mOldChan));
+
+ if (!callback || !mCallbackThread) {
+ LOG(("nsAsyncRedirectVerifyHelper::ExplicitCallback() "
+ "callback=%p mCallbackThread=%p", callback.get(), mCallbackThread.get()));
+ return;
+ }
+
+ mCallbackInitiated = false; // reset to ensure only one callback
+ mWaitingForRedirectCallback = false;
+
+ // Now, dispatch the callback on the event-target which called Init()
+ nsCOMPtr<nsIRunnable> event =
+ new nsAsyncVerifyRedirectCallbackEvent(callback, result);
+ if (!event) {
+ NS_WARNING("nsAsyncRedirectVerifyHelper::ExplicitCallback() "
+ "failed creating callback event!");
+ return;
+ }
+ nsresult rv = mCallbackThread->Dispatch(event, NS_DISPATCH_NORMAL);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("nsAsyncRedirectVerifyHelper::ExplicitCallback() "
+ "failed dispatching callback event!");
+ } else {
+ LOG(("nsAsyncRedirectVerifyHelper::ExplicitCallback() "
+ "dispatched callback event=%p", event.get()));
+ }
+
+}
+
+void
+nsAsyncRedirectVerifyHelper::InitCallback()
+{
+ LOG(("nsAsyncRedirectVerifyHelper::InitCallback() "
+ "expectedCBs=%d mResult=%x", mExpectedCallbacks, mResult));
+
+ mCallbackInitiated = true;
+
+ // Invoke the callback if we are done
+ if (mExpectedCallbacks == 0)
+ ExplicitCallback(mResult);
+}
+
+NS_IMETHODIMP
+nsAsyncRedirectVerifyHelper::Run()
+{
+ /* If the channel got canceled after it fired AsyncOnChannelRedirect
+ * and before we got here, mostly because docloader load has been canceled,
+ * we must completely ignore this notification and prevent any further
+ * notification.
+ */
+ if (IsOldChannelCanceled()) {
+ ExplicitCallback(NS_BINDING_ABORTED);
+ return NS_OK;
+ }
+
+ // First, the global observer
+ NS_ASSERTION(gIOService, "Must have an IO service at this point");
+ LOG(("nsAsyncRedirectVerifyHelper::Run() calling gIOService..."));
+ nsresult rv = gIOService->AsyncOnChannelRedirect(mOldChan, mNewChan,
+ mFlags, this);
+ if (NS_FAILED(rv)) {
+ ExplicitCallback(rv);
+ return NS_OK;
+ }
+
+ // Now, the per-channel observers
+ nsCOMPtr<nsIChannelEventSink> sink;
+ NS_QueryNotificationCallbacks(mOldChan, sink);
+ if (sink) {
+ LOG(("nsAsyncRedirectVerifyHelper::Run() calling sink..."));
+ rv = DelegateOnChannelRedirect(sink, mOldChan, mNewChan, mFlags);
+ }
+
+ // All invocations to AsyncOnChannelRedirect has been done - call
+ // InitCallback() to flag this
+ InitCallback();
+ return NS_OK;
+}
+
+bool
+nsAsyncRedirectVerifyHelper::IsOldChannelCanceled()
+{
+ bool canceled;
+ nsCOMPtr<nsIHttpChannelInternal> oldChannelInternal =
+ do_QueryInterface(mOldChan);
+ if (oldChannelInternal) {
+ oldChannelInternal->GetCanceled(&canceled);
+ if (canceled) {
+ return true;
+ }
+ } else if (mOldChan) {
+ // For non-HTTP channels check on the status, failure
+ // indicates the channel has probably been canceled.
+ nsresult status = NS_ERROR_FAILURE;
+ mOldChan->GetStatus(&status);
+ if (NS_FAILED(status)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+} // namespace net
+} // namespace mozilla