Bug 1760580 - P1: Make nsIRequest support to store canceled reason, r=necko-reviewers,valentin

Differential Revision: https://phabricator.services.mozilla.com/D156070

docshell/base/nsDocShell.cpp

@@ -931,6 +931,19 @@ StopDetector::GetStatus(nsresult* aStatus) {
   return NS_OK;
 }
 
+NS_IMETHODIMP StopDetector::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP StopDetector::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP StopDetector::CancelWithReason(nsresult aStatus,
+                                             const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 StopDetector::Cancel(nsresult aStatus) {
   mCanceled = true;

dom/base/Document.cpp

@@ -772,6 +772,18 @@ OnloadBlocker::GetStatus(nsresult* status) {
   return NS_OK;
 }
 
+NS_IMETHODIMP OnloadBlocker::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP OnloadBlocker::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP OnloadBlocker::CancelWithReason(nsresult aStatus,
+                                              const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
 NS_IMETHODIMP
 OnloadBlocker::Cancel(nsresult status) { return NS_OK; }
 NS_IMETHODIMP

dom/ipc/RemoteWebProgressRequest.cpp

@@ -180,6 +180,20 @@ NS_IMETHODIMP RemoteWebProgressRequest::GetStatus(nsresult* aStatus) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
+NS_IMETHODIMP RemoteWebProgressRequest::SetCanceledReason(
+    const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::CancelWithReason(
+    nsresult aStatus, const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP RemoteWebProgressRequest::Cancel(nsresult aStatus) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }

dom/jsurl/nsJSProtocolHandler.cpp

@@ -509,6 +509,19 @@ nsJSChannel::GetStatus(nsresult* aResult) {
   return NS_OK;
 }
 
+NS_IMETHODIMP nsJSChannel::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsJSChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsJSChannel::CancelWithReason(nsresult aStatus,
+                                            const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 nsJSChannel::Cancel(nsresult aStatus) {
   mStatus = aStatus;

dom/websocket/WebSocket.cpp

@@ -2549,6 +2549,19 @@ class CancelRunnable final : public MainThreadWorkerRunnable {
 
 }  // namespace
 
+NS_IMETHODIMP WebSocketImpl::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP WebSocketImpl::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP WebSocketImpl::CancelWithReason(nsresult aStatus,
+                                              const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 // Window closed, stop/reload button pressed, user navigated away from page,
 // etc.
 NS_IMETHODIMP

dom/xslt/xslt/txMozillaXSLTProcessor.cpp

@@ -593,6 +593,19 @@ XSLTProcessRequest::GetStatus(nsresult* status) {
   return NS_OK;
 }
 
+NS_IMETHODIMP XSLTProcessRequest::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP XSLTProcessRequest::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP XSLTProcessRequest::CancelWithReason(nsresult aStatus,
+                                                   const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 XSLTProcessRequest::Cancel(nsresult status) {
   mState->stopProcessing();

image/decoders/icon/mac/nsIconChannelCocoa.mm

@@ -66,6 +66,19 @@ nsIconChannel::IsPending(bool* result) { return mPump->IsPending(result); }
 NS_IMETHODIMP
 nsIconChannel::GetStatus(nsresult* status) { return mPump->GetStatus(status); }
 
+NS_IMETHODIMP nsIconChannel::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsIconChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsIconChannel::CancelWithReason(nsresult aStatus,
+                                              const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 nsIconChannel::Cancel(nsresult status) {
   mCanceled = true;

image/decoders/icon/win/nsIconChannel.cpp

@@ -590,6 +590,19 @@ nsIconChannel::IsPending(bool* result) { return mPump->IsPending(result); }
 NS_IMETHODIMP
 nsIconChannel::GetStatus(nsresult* status) { return mPump->GetStatus(status); }
 
+NS_IMETHODIMP nsIconChannel::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsIconChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsIconChannel::CancelWithReason(nsresult aStatus,
+                                              const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 nsIconChannel::Cancel(nsresult status) {
   mCanceled = true;

image/imgRequestProxy.cpp

@@ -440,6 +440,19 @@ imgRequestProxy::GetStatus(nsresult* aStatus) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
+NS_IMETHODIMP imgRequestProxy::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP imgRequestProxy::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP imgRequestProxy::CancelWithReason(nsresult aStatus,
+                                                const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 imgRequestProxy::Cancel(nsresult status) {
   if (mCanceled) {

modules/libjar/nsJARChannel.cpp

@@ -570,6 +570,19 @@ nsJARChannel::GetStatus(nsresult* status) {
   return NS_OK;
 }
 
+NS_IMETHODIMP nsJARChannel::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsJARChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsJARChannel::CancelWithReason(nsresult aStatus,
+                                             const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 nsJARChannel::Cancel(nsresult status) {
   mCanceled = true;

netwerk/base/nsAsyncStreamCopier.cpp

@@ -155,6 +155,20 @@ nsAsyncStreamCopier::GetStatus(nsresult* status) {
   return NS_OK;
 }
 
+NS_IMETHODIMP nsAsyncStreamCopier::SetCanceledReason(
+    const nsACString& aReason) {
+  return nsIAsyncStreamCopier::SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsAsyncStreamCopier::GetCanceledReason(nsACString& aReason) {
+  return nsIAsyncStreamCopier::GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsAsyncStreamCopier::CancelWithReason(nsresult aStatus,
+                                                    const nsACString& aReason) {
+  return nsIAsyncStreamCopier::CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 nsAsyncStreamCopier::Cancel(nsresult status) {
   nsCOMPtr<nsISupports> copierCtx;

netwerk/base/nsBaseChannel.cpp

@@ -366,6 +366,19 @@ nsBaseChannel::GetStatus(nsresult* status) {
   return NS_OK;
 }
 
+NS_IMETHODIMP nsBaseChannel::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsBaseChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsBaseChannel::CancelWithReason(nsresult aStatus,
+                                              const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 nsBaseChannel::Cancel(nsresult status) {
   // Ignore redundant cancelation

netwerk/base/nsIRequest.idl

@@ -5,6 +5,10 @@
 
 #include "nsISupports.idl"
 
+%{ C++
+#include "nsString.h"
+%}
+
 interface nsILoadGroup;
 
 typedef unsigned long nsLoadFlags;
@@ -202,6 +206,34 @@ interface nsIRequest : nsISupports
     const unsigned long LOAD_TRR_FIRST_MODE = 1 << 4;
     const unsigned long LOAD_TRR_ONLY_MODE = (1 << 3) | (1 << 4);
 
+    void cancelWithReason(in nsresult aStatus, in ACString aReason);
+    attribute ACString canceledReason;
+
+    %{C++
+      protected:
+        nsCString mCanceledReason;
+
+      public:
+        inline nsresult SetCanceledReasonImpl(const nsACString& aReason) {
+          if (mCanceledReason.IsEmpty()) {
+            mCanceledReason.Assign(aReason);
+          }
+
+          return NS_OK;
+        }
+
+        inline nsresult CancelWithReasonImpl(nsresult aStatus,
+                                             const nsACString& aReason) {
+          SetCanceledReasonImpl(aReason);
+          return Cancel(aStatus);
+        }
+
+        inline nsresult GetCanceledReasonImpl(nsACString& aReason) {
+          aReason.Assign(mCanceledReason);
+          return NS_OK;
+        }
+    %}
+
     /**
      * This is used for a temporary workaround for a web-compat issue. The flag is
      * only set on CORS preflight request to allowed sending client certificates

netwerk/base/nsIncrementalDownload.cpp

@@ -325,6 +325,20 @@ nsIncrementalDownload::GetStatus(nsresult* status) {
   return NS_OK;
 }
 
+NS_IMETHODIMP nsIncrementalDownload::SetCanceledReason(
+    const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsIncrementalDownload::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsIncrementalDownload::CancelWithReason(
+    nsresult aStatus, const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 nsIncrementalDownload::Cancel(nsresult status) {
   NS_ENSURE_ARG(NS_FAILED(status));

netwerk/base/nsInputStreamPump.cpp

@@ -166,6 +166,19 @@ nsInputStreamPump::GetStatus(nsresult* status) {
   return NS_OK;
 }
 
+NS_IMETHODIMP nsInputStreamPump::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsInputStreamPump::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsInputStreamPump::CancelWithReason(nsresult aStatus,
+                                                  const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 nsInputStreamPump::Cancel(nsresult status) {
   RecursiveMutexAutoLock lock(mMutex);

netwerk/base/nsLoadGroup.cpp

@@ -170,6 +170,19 @@ static bool AppendRequestsToArray(PLDHashTable* aTable,
   return true;
 }
 
+NS_IMETHODIMP nsLoadGroup::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsLoadGroup::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsLoadGroup::CancelWithReason(nsresult aStatus,
+                                            const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 nsLoadGroup::Cancel(nsresult status) {
   MOZ_ASSERT(NS_IsMainThread());

netwerk/ipc/DocumentChannel.cpp

@@ -193,6 +193,19 @@ already_AddRefed<DocumentChannel> DocumentChannel::CreateForObject(
                            aNotificationCallbacks, 0, false, false);
 }
 
+NS_IMETHODIMP DocumentChannel::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP DocumentChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP DocumentChannel::CancelWithReason(nsresult aStatus,
+                                                const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 DocumentChannel::Cancel(nsresult aStatusCode) {
   MOZ_CRASH("If we get here, something is broken");

netwerk/protocol/http/ClassifierDummyChannel.cpp

@@ -267,6 +267,20 @@ ClassifierDummyChannel::GetStatus(nsresult* aStatus) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
+NS_IMETHODIMP ClassifierDummyChannel::SetCanceledReason(
+    const nsACString& aReason) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP ClassifierDummyChannel::GetCanceledReason(nsACString& aReason) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP ClassifierDummyChannel::CancelWithReason(
+    nsresult aStatus, const nsACString& aReason) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
 NS_IMETHODIMP
 ClassifierDummyChannel::Cancel(nsresult aStatus) {
   return NS_ERROR_NOT_IMPLEMENTED;

netwerk/protocol/http/HttpChannelChild.cpp

@@ -1763,6 +1763,20 @@ HttpChannelChild::OnRedirectVerifyCallback(nsresult aResult) {
 // HttpChannelChild::nsIRequest
 //-----------------------------------------------------------------------------
 
+NS_IMETHODIMP HttpChannelChild::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP HttpChannelChild::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP
+HttpChannelChild::CancelWithReason(nsresult aStatus,
+                                   const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 HttpChannelChild::Cancel(nsresult aStatus) {
   LOG(("HttpChannelChild::Cancel [this=%p, status=%" PRIx32 "]\n", this,

netwerk/protocol/http/HttpChannelChild.h

@@ -80,6 +80,10 @@ class HttpChannelChild final : public PHttpChannelChild,
   // Methods HttpBaseChannel didn't implement for us or that we override.
   //
   // nsIRequest
+  NS_IMETHOD SetCanceledReason(const nsACString& aReason) override;
+  NS_IMETHOD GetCanceledReason(nsACString& aReason) override;
+  NS_IMETHOD CancelWithReason(nsresult status,
+                              const nsACString& reason) override;
   NS_IMETHOD Cancel(nsresult status) override;
   NS_IMETHOD Suspend() override;
   NS_IMETHOD Resume() override;

netwerk/protocol/http/HttpTransactionParent.cpp

@@ -703,6 +703,20 @@ HttpTransactionParent::GetStatus(nsresult* aStatus) {
   return NS_OK;
 }
 
+NS_IMETHODIMP HttpTransactionParent::SetCanceledReason(
+    const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP HttpTransactionParent::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP HttpTransactionParent::CancelWithReason(
+    nsresult aStatus, const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 HttpTransactionParent::Cancel(nsresult aStatus) {
   MOZ_ASSERT(NS_IsMainThread());

netwerk/protocol/http/InterceptedHttpChannel.cpp

@@ -489,6 +489,21 @@ InterceptedHttpChannel::CreateForSynthesis(
   return ref.forget();
 }
 
+NS_IMETHODIMP InterceptedHttpChannel::SetCanceledReason(
+    const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP InterceptedHttpChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP
+InterceptedHttpChannel::CancelWithReason(nsresult aStatus,
+                                         const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 InterceptedHttpChannel::Cancel(nsresult aStatus) {
   // Note: This class has been designed to send all error results through

netwerk/protocol/http/InterceptedHttpChannel.h

@@ -228,6 +228,11 @@ class InterceptedHttpChannel final
       const TimeStamp& aCreationTimestamp,
       const TimeStamp& aAsyncOpenTimestamp);
 
+  NS_IMETHOD SetCanceledReason(const nsACString& aReason) override;
+  NS_IMETHOD GetCanceledReason(nsACString& aReason) override;
+  NS_IMETHOD CancelWithReason(nsresult status,
+                              const nsACString& reason) override;
+
   NS_IMETHOD
   Cancel(nsresult aStatus) override;
 

netwerk/protocol/http/NullHttpChannel.cpp

@@ -424,6 +424,19 @@ NullHttpChannel::GetStatus(nsresult* aStatus) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
+NS_IMETHODIMP NullHttpChannel::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP NullHttpChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP NullHttpChannel::CancelWithReason(nsresult aStatus,
+                                                const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 NullHttpChannel::Cancel(nsresult aStatus) { return NS_ERROR_NOT_IMPLEMENTED; }
 

netwerk/protocol/http/TRRServiceChannel.cpp

@@ -97,6 +97,20 @@ TRRServiceChannel::~TRRServiceChannel() {
   LOG(("TRRServiceChannel dtor [this=%p]\n", this));
 }
 
+NS_IMETHODIMP TRRServiceChannel::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP TRRServiceChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP
+TRRServiceChannel::CancelWithReason(nsresult aStatus,
+                                    const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 TRRServiceChannel::Cancel(nsresult status) {
   LOG(("TRRServiceChannel::Cancel [this=%p status=%" PRIx32 "]\n", this,

netwerk/protocol/http/TRRServiceChannel.h

@@ -52,6 +52,10 @@ class TRRServiceChannel : public HttpBaseChannel,
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_TRRSERVICECHANNEL_IID)
 
   // nsIRequest
+  NS_IMETHOD SetCanceledReason(const nsACString& aReason) override;
+  NS_IMETHOD GetCanceledReason(nsACString& aReason) override;
+  NS_IMETHOD CancelWithReason(nsresult status,
+                              const nsACString& reason) override;
   NS_IMETHOD Cancel(nsresult status) override;
   NS_IMETHOD Suspend() override;
   NS_IMETHOD Resume() override;

netwerk/protocol/http/nsHttpChannel.cpp

@@ -5441,6 +5441,19 @@ NS_INTERFACE_MAP_END_INHERITING(HttpBaseChannel)
 // nsHttpChannel::nsIRequest
 //-----------------------------------------------------------------------------
 
+NS_IMETHODIMP nsHttpChannel::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsHttpChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP
+nsHttpChannel::CancelWithReason(nsresult aStatus, const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 nsHttpChannel::Cancel(nsresult status) {
   MOZ_ASSERT(NS_IsMainThread());

netwerk/protocol/http/nsHttpChannel.h

@@ -142,6 +142,10 @@ class nsHttpChannel final : public HttpBaseChannel,
   // Methods HttpBaseChannel didn't implement for us or that we override.
   //
   // nsIRequest
+  NS_IMETHOD SetCanceledReason(const nsACString& aReason) override;
+  NS_IMETHOD GetCanceledReason(nsACString& aReason) override;
+  NS_IMETHOD CancelWithReason(nsresult status,
+                              const nsACString& reason) override;
   NS_IMETHOD Cancel(nsresult status) override;
   NS_IMETHOD Suspend() override;
   NS_IMETHOD Resume() override;

netwerk/protocol/viewsource/nsViewSourceChannel.cpp

@@ -263,6 +263,20 @@ nsViewSourceChannel::GetStatus(nsresult* status) {
   return mChannel->GetStatus(status);
 }
 
+NS_IMETHODIMP nsViewSourceChannel::SetCanceledReason(
+    const nsACString& aReason) {
+  return nsIViewSourceChannel::SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsViewSourceChannel::GetCanceledReason(nsACString& aReason) {
+  return nsIViewSourceChannel::GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsViewSourceChannel::CancelWithReason(nsresult aStatus,
+                                                    const nsACString& aReason) {
+  return nsIViewSourceChannel::CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 nsViewSourceChannel::Cancel(nsresult status) {
   NS_ENSURE_TRUE(mChannel, NS_ERROR_FAILURE);

netwerk/streamconv/converters/nsMultiMixedConv.cpp

@@ -118,6 +118,19 @@ nsPartChannel::GetStatus(nsresult* aResult) {
   return rv;
 }
 
+NS_IMETHODIMP nsPartChannel::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsPartChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsPartChannel::CancelWithReason(nsresult aStatus,
+                                              const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 nsPartChannel::Cancel(nsresult aStatus) {
   // Cancelling an individual part must not cancel the underlying

netwerk/test/unit/test_httpcancel.js

@@ -10,6 +10,7 @@
 "use strict";
 
 const { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
+const reason = "testing";
 
 function inChildProcess() {
   return Services.appinfo.processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
@@ -26,7 +27,7 @@ var observer = {
 
   observe(subject, topic, data) {
     subject = subject.QueryInterface(Ci.nsIRequest);
-    subject.cancel(Cr.NS_BINDING_ABORTED);
+    subject.cancelWithReason(Cr.NS_BINDING_ABORTED, reason);
 
     // ENSURE_CALLED_BEFORE_CONNECT: setting values should still work
     try {
@@ -48,6 +49,10 @@ var observer = {
 let cancelDuringOnStartListener = {
   onStartRequest: function test_onStartR(request) {
     Assert.equal(request.status, Cr.NS_BINDING_ABORTED);
+    // We didn't sync the reason to child process.
+    if (!inChildProcess()) {
+      Assert.equal(request.canceledReason, reason);
+    }
 
     // ENSURE_CALLED_BEFORE_CONNECT: setting referrer should now fail
     try {

toolkit/components/bitsdownload/src/bits_interface/request.rs

@@ -725,6 +725,28 @@ impl BitsRequest {
     fn set_trr_mode(&self, _trr_mode: u8) -> Result<(), nsresult> {
         Err(NS_ERROR_NOT_IMPLEMENTED)
     }
+
+    xpcom_method!(
+        get_canceled_reason => GetCanceledReason() -> nsACString
+    );
+    fn get_canceled_reason(&self) -> Result<nsCString, nsresult> {
+        Err(NS_ERROR_NOT_IMPLEMENTED)
+    }
+
+    xpcom_method!(
+        set_canceled_reason => SetCanceledReason(_reason: *const nsACString)
+    );
+    fn set_canceled_reason(&self, _reason: *const nsACString) -> Result<(), nsresult> {
+        Err(NS_ERROR_NOT_IMPLEMENTED)
+    }
+
+    xpcom_method!(
+        cancel_with_reason_nsIRequest => CancelWithReason(status: nsresult, _reason: *const nsACString)
+    );
+    #[allow(non_snake_case)]
+    fn cancel_with_reason_nsIRequest(&self, status: nsresult,  _reason: *const nsACString) -> Result<(), BitsTaskError> {
+        self.cancel(status, None)
+    }
 }
 
 impl Drop for BitsRequest {

toolkit/components/extensions/webrequest/StreamFilterParent.cpp

@@ -428,6 +428,19 @@ StreamFilterParent::IsPending(bool* aIsPending) {
   return NS_OK;
 }
 
+NS_IMETHODIMP StreamFilterParent::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP StreamFilterParent::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP StreamFilterParent::CancelWithReason(nsresult aStatus,
+                                                   const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 StreamFilterParent::Cancel(nsresult aResult) {
   AssertIsMainThread();

uriloader/exthandler/ExternalHelperAppParent.cpp

@@ -202,6 +202,20 @@ ExternalHelperAppParent::GetStatus(nsresult* aResult) {
   return NS_OK;
 }
 
+NS_IMETHODIMP ExternalHelperAppParent::SetCanceledReason(
+    const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP ExternalHelperAppParent::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP ExternalHelperAppParent::CancelWithReason(
+    nsresult aStatus, const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP
 ExternalHelperAppParent::Cancel(nsresult aStatus) {
   mCanceled = true;

uriloader/exthandler/nsExternalProtocolHandler.cpp

@@ -347,6 +347,20 @@ NS_IMETHODIMP nsExtProtocolChannel::GetStatus(nsresult* status) {
   return NS_OK;
 }
 
+NS_IMETHODIMP nsExtProtocolChannel::SetCanceledReason(
+    const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsExtProtocolChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP nsExtProtocolChannel::CancelWithReason(
+    nsresult aStatus, const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
 NS_IMETHODIMP nsExtProtocolChannel::Cancel(nsresult status) {
   if (NS_SUCCEEDED(mStatus)) {
     mStatus = status;

uriloader/preload/gtest/TestFetchPreloader.cpp

@@ -62,6 +62,16 @@ NS_IMETHODIMP FakeChannel::GetStatus(nsresult* status) {
   *status = mStatus;
   return NS_OK;
 }
+NS_IMETHODIMP FakeChannel::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+NS_IMETHODIMP FakeChannel::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+NS_IMETHODIMP FakeChannel::CancelWithReason(nsresult aStatus,
+                                            const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
 NS_IMETHODIMP FakeChannel::Cancel(nsresult status) {
   if (!mCanceled) {
     mCanceled = true;