--- a/modules/libjar/nsJARURI.cpp
+++ b/modules/libjar/nsJARURI.cpp
@@ -287,24 +287,28 @@ nsJARURI::SetSpecWithBase(const nsACStri
             return NS_ERROR_MALFORMED_URI;
 
         RefPtr<nsJARURI> otherJAR;
         aBaseURL->QueryInterface(NS_GET_IID(nsJARURI), getter_AddRefs(otherJAR));
         NS_ENSURE_TRUE(otherJAR, NS_NOINTERFACE);
 
         mJARFile = otherJAR->mJARFile;
 
-        nsCOMPtr<nsIStandardURL> entry(do_CreateInstance(NS_STANDARDURL_CONTRACTID));
-        if (!entry)
-            return NS_ERROR_OUT_OF_MEMORY;
+        nsCOMPtr<nsIURI> entry;
 
-        rv = entry->Init(nsIStandardURL::URLTYPE_NO_AUTHORITY, -1,
-                         aSpec, mCharsetHint.get(), otherJAR->mJAREntry);
-        if (NS_FAILED(rv))
+        rv = NS_MutateURI(NS_STANDARDURLMUTATOR_CONTRACTID)
+               .Apply<nsIStandardURLMutator>(&nsIStandardURLMutator::Init,
+                                             nsIStandardURL::URLTYPE_NO_AUTHORITY, -1,
+                                             nsCString(aSpec), mCharsetHint.get(),
+                                             otherJAR->mJAREntry,
+                                             nullptr)
+               .Finalize(entry);
+        if (NS_FAILED(rv)) {
             return rv;
+        }
 
         mJAREntry = do_QueryInterface(entry);
         if (!mJAREntry)
             return NS_NOINTERFACE;
 
         return NS_OK;
     }
 

--- a/netwerk/base/nsStandardURL.h
+++ b/netwerk/base/nsStandardURL.h
@@ -308,67 +308,108 @@ private:
     static bool                         gPunycodeHost;
 
 public:
 #ifdef DEBUG_DUMP_URLS_AT_SHUTDOWN
     void PrintSpec() const { printf("  %s\n", mSpec.get()); }
 #endif
 
 public:
-    class Mutator
+
+    // We make this implementation a template so that we can avoid writing
+    // the same code for SubstitutingURL (which extends nsStandardURL)
+    template<class T>
+    class TemplatedMutator
         : public nsIURIMutator
-        , public BaseURIMutator<nsStandardURL>
+        , public BaseURIMutator<T>
         , public nsIStandardURLMutator
     {
-        NS_DECL_ISUPPORTS
-        NS_FORWARD_SAFE_NSIURISETTERS_RET(mURI)
-        NS_DEFINE_NSIMUTATOR_COMMON
+        NS_FORWARD_SAFE_NSIURISETTERS_RET(BaseURIMutator<T>::mURI)
+
+        MOZ_MUST_USE NS_IMETHOD
+        Deserialize(const mozilla::ipc::URIParams& aParams) override
+        {
+            return BaseURIMutator<T>::InitFromIPCParams(aParams);
+        }
+
+        MOZ_MUST_USE NS_IMETHOD
+        Read(nsIObjectInputStream* aStream) override
+        {
+            return BaseURIMutator<T>::InitFromInputStream(aStream);
+        }
+
+        MOZ_MUST_USE NS_IMETHOD
+        Finalize(nsIURI** aURI) override
+        {
+            BaseURIMutator<T>::mURI.forget(aURI);
+            return NS_OK;
+        }
+
+        MOZ_MUST_USE NS_IMETHOD
+        SetSpec(const nsACString& aSpec, nsIURIMutator** aMutator) override
+        {
+            if (aMutator) {
+                nsCOMPtr<nsIURIMutator> mutator = this;
+                mutator.forget(aMutator);
+            }
+            return BaseURIMutator<T>::InitFromSpec(aSpec);
+        }
 
         MOZ_MUST_USE NS_IMETHOD
         Init(uint32_t aURLType, int32_t aDefaultPort,
              const nsACString& aSpec, const char* aCharset, nsIURI* aBaseURI,
              nsIURIMutator** aMutator) override
         {
             if (aMutator) {
                 nsCOMPtr<nsIURIMutator> mutator = this;
                 mutator.forget(aMutator);
             }
-            RefPtr<nsStandardURL> uri;
-            if (mURI) {
-              // We don't need to instantiate a new object we already have one
-              mURI.swap(uri);
+            RefPtr<T> uri;
+            if (BaseURIMutator<T>::mURI) {
+                // We don't need a new URI object if we already have one
+                BaseURIMutator<T>::mURI.swap(uri);
             } else {
-              uri = new nsStandardURL();
+                uri = new T();
             }
             nsresult rv = uri->Init(aURLType, aDefaultPort, aSpec, aCharset, aBaseURI);
             if (NS_FAILED(rv)) {
                 return rv;
             }
-            mURI = uri;
+            BaseURIMutator<T>::mURI = uri;
             return NS_OK;
         }
 
         MOZ_MUST_USE NS_IMETHODIMP
         SetDefaultPort(int32_t aNewDefaultPort, nsIURIMutator** aMutator) override
         {
-            if (!mURI) {
+            if (!BaseURIMutator<T>::mURI) {
                 return NS_ERROR_NULL_POINTER;
             }
             if (aMutator) {
                 nsCOMPtr<nsIURIMutator> mutator = this;
                 mutator.forget(aMutator);
             }
-            return mURI->SetDefaultPort(aNewDefaultPort);
+            return BaseURIMutator<T>::mURI->SetDefaultPort(aNewDefaultPort);
         }
 
-        explicit Mutator() { }
+        explicit TemplatedMutator() { }
     private:
-        virtual ~Mutator() { }
+        virtual ~TemplatedMutator() { }
+
+        friend T;
+    };
 
-        friend class nsStandardURL;
+    class Mutator
+        : public TemplatedMutator<nsStandardURL>
+    {
+        NS_DECL_ISUPPORTS
+    public:
+        explicit Mutator() = default;
+    private:
+        virtual ~Mutator() = default;
     };
 };
 
 #define NS_THIS_STANDARDURL_IMPL_CID                 \
 { /* b8e3e97b-1ccd-4b45-af5a-79596770f5d7 */         \
     0xb8e3e97b,                                      \
     0x1ccd,                                          \
     0x4b45,                                          \

--- a/netwerk/protocol/res/SubstitutingProtocolHandler.h
+++ b/netwerk/protocol/res/SubstitutingProtocolHandler.h
@@ -121,14 +121,35 @@ private:
 // SubstitutingURL : overrides nsStandardURL::GetFile to provide nsIFile resolution
 class SubstitutingURL : public nsStandardURL
 {
 public:
   SubstitutingURL() : nsStandardURL(true) {}
   virtual nsStandardURL* StartClone() override;
   virtual MOZ_MUST_USE nsresult EnsureFile() override;
   NS_IMETHOD GetClassIDNoAlloc(nsCID *aCID) override;
+
+  class Mutator
+    : public TemplatedMutator<SubstitutingURL>
+  {
+    NS_DECL_ISUPPORTS
+  public:
+    explicit Mutator() = default;
+  private:
+    virtual ~Mutator() = default;
+  };
+
+  NS_IMETHOD Mutate(nsIURIMutator** aMutator) override
+  {
+    RefPtr<SubstitutingURL::Mutator> mutator = new SubstitutingURL::Mutator();
+    nsresult rv = mutator->InitFromURI(this);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+    mutator.forget(aMutator);
+    return NS_OK;
+  }
 };
 
 } // namespace net
 } // namespace mozilla
 
 #endif /* SubstitutingProtocolHandler_h___ */