Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 647 insertions, 0 deletions

diff --git a/dom/html/HTMLDNSPrefetch.cpp b/dom/html/HTMLDNSPrefetch.cpp
new file mode 100644
index 0000000000..a4043195fe
--- /dev/null
+++ b/dom/html/HTMLDNSPrefetch.cpp
@@ -0,0 +1,647 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "HTMLDNSPrefetch.h"
+
+#include "base/basictypes.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/HTMLLinkElement.h"
+#include "mozilla/dom/HTMLAnchorElement.h"
+#include "mozilla/net/NeckoCommon.h"
+#include "mozilla/net/NeckoChild.h"
+#include "mozilla/OriginAttributes.h"
+#include "mozilla/StoragePrincipalHelper.h"
+#include "nsURLHelper.h"
+
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+#include "nsNetUtil.h"
+#include "nsNetCID.h"
+#include "nsIProtocolHandler.h"
+
+#include "nsIDNSListener.h"
+#include "nsIWebProgressListener.h"
+#include "nsIWebProgress.h"
+#include "nsIDNSRecord.h"
+#include "nsIDNSService.h"
+#include "nsICancelable.h"
+#include "nsGkAtoms.h"
+#include "mozilla/dom/Document.h"
+#include "nsThreadUtils.h"
+#include "nsITimer.h"
+#include "nsIObserverService.h"
+
+#include "mozilla/Components.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/StaticPrefs_network.h"
+
+using namespace mozilla::net;
+
+namespace mozilla::dom {
+
+class NoOpDNSListener final : public nsIDNSListener {
+  // This class exists to give a safe callback no-op DNSListener
+ public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIDNSLISTENER
+
+  NoOpDNSListener() = default;
+
+ private:
+  ~NoOpDNSListener() = default;
+};
+
+NS_IMPL_ISUPPORTS(NoOpDNSListener, nsIDNSListener)
+
+NS_IMETHODIMP
+NoOpDNSListener::OnLookupComplete(nsICancelable* request, nsIDNSRecord* rec,
+                                  nsresult status) {
+  return NS_OK;
+}
+
+// This is just a (size) optimization and could be avoided by storing the
+// SupportsDNSPrefetch pointer of the element in the prefetch queue, but given
+// we need this for GetURIForDNSPrefetch...
+static SupportsDNSPrefetch& ToSupportsDNSPrefetch(Element& aElement) {
+  if (auto* link = HTMLLinkElement::FromNode(aElement)) {
+    return *link;
+  }
+  auto* anchor = HTMLAnchorElement::FromNode(aElement);
+  MOZ_DIAGNOSTIC_ASSERT(anchor);
+  return *anchor;
+}
+
+nsIURI* SupportsDNSPrefetch::GetURIForDNSPrefetch(Element& aElement) {
+  MOZ_ASSERT(&ToSupportsDNSPrefetch(aElement) == this);
+  if (auto* link = HTMLLinkElement::FromNode(aElement)) {
+    return link->GetURI();
+  }
+  auto* anchor = HTMLAnchorElement::FromNode(aElement);
+  MOZ_DIAGNOSTIC_ASSERT(anchor);
+  return anchor->GetURI();
+}
+
+class DeferredDNSPrefetches final : public nsIWebProgressListener,
+                                    public nsSupportsWeakReference,
+                                    public nsIObserver {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIWEBPROGRESSLISTENER
+  NS_DECL_NSIOBSERVER
+
+  DeferredDNSPrefetches();
+
+  void Activate();
+  nsresult Add(nsIDNSService::DNSFlags flags, SupportsDNSPrefetch&, Element&);
+
+  void RemoveUnboundLinks();
+
+ private:
+  ~DeferredDNSPrefetches();
+  void Flush();
+
+  void SubmitQueue();
+  void SubmitQueueEntry(Element&, nsIDNSService::DNSFlags aFlags);
+
+  uint16_t mHead;
+  uint16_t mTail;
+  uint32_t mActiveLoaderCount;
+
+  nsCOMPtr<nsITimer> mTimer;
+  bool mTimerArmed;
+  static void Tick(nsITimer* aTimer, void* aClosure);
+
+  static const int sMaxDeferred = 512;  // keep power of 2 for masking
+  static const int sMaxDeferredMask = (sMaxDeferred - 1);
+
+  struct deferred_entry {
+    nsIDNSService::DNSFlags mFlags;
+    // SupportsDNSPrefetch clears this raw pointer in Destroyed().
+    Element* mElement;
+  } mEntries[sMaxDeferred];
+};
+
+static NS_DEFINE_CID(kDNSServiceCID, NS_DNSSERVICE_CID);
+static bool sInitialized = false;
+static nsIDNSService* sDNSService = nullptr;
+static DeferredDNSPrefetches* sPrefetches = nullptr;
+static NoOpDNSListener* sDNSListener = nullptr;
+
+nsresult HTMLDNSPrefetch::Initialize() {
+  if (sInitialized) {
+    NS_WARNING("Initialize() called twice");
+    return NS_OK;
+  }
+
+  sPrefetches = new DeferredDNSPrefetches();
+  NS_ADDREF(sPrefetches);
+
+  sDNSListener = new NoOpDNSListener();
+  NS_ADDREF(sDNSListener);
+
+  sPrefetches->Activate();
+
+  if (IsNeckoChild()) NeckoChild::InitNeckoChild();
+
+  sInitialized = true;
+  return NS_OK;
+}
+
+nsresult HTMLDNSPrefetch::Shutdown() {
+  if (!sInitialized) {
+    NS_WARNING("Not Initialized");
+    return NS_OK;
+  }
+  sInitialized = false;
+  NS_IF_RELEASE(sDNSService);
+  NS_IF_RELEASE(sPrefetches);
+  NS_IF_RELEASE(sDNSListener);
+
+  return NS_OK;
+}
+
+static bool EnsureDNSService() {
+  if (sDNSService) {
+    return true;
+  }
+
+  NS_IF_RELEASE(sDNSService);
+  nsresult rv;
+  rv = CallGetService(kDNSServiceCID, &sDNSService);
+  if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  return !!sDNSService;
+}
+
+bool HTMLDNSPrefetch::IsAllowed(Document* aDocument) {
+  // There is no need to do prefetch on non UI scenarios such as XMLHttpRequest.
+  return aDocument->IsDNSPrefetchAllowed() && aDocument->GetWindow();
+}
+
+static nsIDNSService::DNSFlags GetDNSFlagsFromElement(Element& aElement) {
+  nsIChannel* channel = aElement.OwnerDoc()->GetChannel();
+  if (!channel) {
+    return nsIDNSService::RESOLVE_DEFAULT_FLAGS;
+  }
+  return nsIDNSService::GetFlagsFromTRRMode(channel->GetTRRMode());
+}
+
+nsIDNSService::DNSFlags HTMLDNSPrefetch::PriorityToDNSServiceFlags(
+    Priority aPriority) {
+  switch (aPriority) {
+    case Priority::Low:
+      return nsIDNSService::RESOLVE_PRIORITY_LOW;
+    case Priority::Medium:
+      return nsIDNSService::RESOLVE_PRIORITY_MEDIUM;
+    case Priority::High:
+      return nsIDNSService::RESOLVE_DEFAULT_FLAGS;
+  }
+  MOZ_ASSERT_UNREACHABLE("Unknown priority");
+  return nsIDNSService::RESOLVE_DEFAULT_FLAGS;
+}
+
+nsresult HTMLDNSPrefetch::Prefetch(SupportsDNSPrefetch& aSupports,
+                                   Element& aElement, Priority aPriority) {
+  MOZ_ASSERT(&ToSupportsDNSPrefetch(aElement) == &aSupports);
+  if (!(sInitialized && sPrefetches && sDNSListener) || !EnsureDNSService()) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  return sPrefetches->Add(
+      GetDNSFlagsFromElement(aElement) | PriorityToDNSServiceFlags(aPriority),
+      aSupports, aElement);
+}
+
+nsresult HTMLDNSPrefetch::Prefetch(
+    const nsAString& hostname, bool isHttps,
+    const OriginAttributes& aPartitionedPrincipalOriginAttributes,
+    nsIDNSService::DNSFlags flags) {
+  if (IsNeckoChild()) {
+    // We need to check IsEmpty() because net_IsValidHostName()
+    // considers empty strings to be valid hostnames
+    if (!hostname.IsEmpty() &&
+        net_IsValidHostName(NS_ConvertUTF16toUTF8(hostname))) {
+      // during shutdown gNeckoChild might be null
+      if (gNeckoChild) {
+        gNeckoChild->SendHTMLDNSPrefetch(
+            hostname, isHttps, aPartitionedPrincipalOriginAttributes, flags);
+      }
+    }
+    return NS_OK;
+  }
+
+  if (!(sInitialized && sPrefetches && sDNSListener) || !EnsureDNSService())
+    return NS_ERROR_NOT_AVAILABLE;
+
+  nsCOMPtr<nsICancelable> tmpOutstanding;
+  nsresult rv = sDNSService->AsyncResolveNative(
+      NS_ConvertUTF16toUTF8(hostname), nsIDNSService::RESOLVE_TYPE_DEFAULT,
+      flags | nsIDNSService::RESOLVE_SPECULATE, nullptr, sDNSListener, nullptr,
+      aPartitionedPrincipalOriginAttributes, getter_AddRefs(tmpOutstanding));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  if (StaticPrefs::network_dns_upgrade_with_https_rr() ||
+      StaticPrefs::network_dns_use_https_rr_as_altsvc()) {
+    Unused << sDNSService->AsyncResolveNative(
+        NS_ConvertUTF16toUTF8(hostname), nsIDNSService::RESOLVE_TYPE_HTTPSSVC,
+        flags | nsIDNSService::RESOLVE_SPECULATE, nullptr, sDNSListener,
+        nullptr, aPartitionedPrincipalOriginAttributes,
+        getter_AddRefs(tmpOutstanding));
+  }
+
+  return NS_OK;
+}
+
+nsresult HTMLDNSPrefetch::Prefetch(
+    const nsAString& hostname, bool isHttps,
+    const OriginAttributes& aPartitionedPrincipalOriginAttributes,
+    nsIRequest::TRRMode aMode, Priority aPriority) {
+  return Prefetch(hostname, isHttps, aPartitionedPrincipalOriginAttributes,
+                  nsIDNSService::GetFlagsFromTRRMode(aMode) |
+                      PriorityToDNSServiceFlags(aPriority));
+}
+
+nsresult HTMLDNSPrefetch::CancelPrefetch(SupportsDNSPrefetch& aSupports,
+                                         Element& aElement, Priority aPriority,
+                                         nsresult aReason) {
+  MOZ_ASSERT(&ToSupportsDNSPrefetch(aElement) == &aSupports);
+
+  if (!(sInitialized && sPrefetches && sDNSListener) || !EnsureDNSService()) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsIDNSService::DNSFlags flags =
+      GetDNSFlagsFromElement(aElement) | PriorityToDNSServiceFlags(aPriority);
+
+  nsIURI* uri = aSupports.GetURIForDNSPrefetch(aElement);
+  if (!uri) {
+    return NS_OK;
+  }
+
+  nsAutoCString hostname;
+  uri->GetAsciiHost(hostname);
+
+  nsAutoString protocol;
+  bool isHttps = uri->SchemeIs("https");
+
+  OriginAttributes oa;
+  StoragePrincipalHelper::GetOriginAttributesForNetworkState(
+      aElement.OwnerDoc(), oa);
+
+  return CancelPrefetch(NS_ConvertUTF8toUTF16(hostname), isHttps, oa, flags,
+                        aReason);
+}
+
+nsresult HTMLDNSPrefetch::CancelPrefetch(
+    const nsAString& hostname, bool isHttps,
+    const OriginAttributes& aPartitionedPrincipalOriginAttributes,
+    nsIDNSService::DNSFlags flags, nsresult aReason) {
+  // Forward this request to Necko Parent if we're a child process
+  if (IsNeckoChild()) {
+    // We need to check IsEmpty() because net_IsValidHostName()
+    // considers empty strings to be valid hostnames
+    if (!hostname.IsEmpty() &&
+        net_IsValidHostName(NS_ConvertUTF16toUTF8(hostname))) {
+      // during shutdown gNeckoChild might be null
+      if (gNeckoChild) {
+        gNeckoChild->SendCancelHTMLDNSPrefetch(
+            hostname, isHttps, aPartitionedPrincipalOriginAttributes, flags,
+            aReason);
+      }
+    }
+    return NS_OK;
+  }
+
+  if (!(sInitialized && sPrefetches && sDNSListener) || !EnsureDNSService()) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  // Forward cancellation to DNS service
+  nsresult rv = sDNSService->CancelAsyncResolveNative(
+      NS_ConvertUTF16toUTF8(hostname), nsIDNSService::RESOLVE_TYPE_DEFAULT,
+      flags | nsIDNSService::RESOLVE_SPECULATE,
+      nullptr,  // AdditionalInfo
+      sDNSListener, aReason, aPartitionedPrincipalOriginAttributes);
+
+  if (StaticPrefs::network_dns_upgrade_with_https_rr() ||
+      StaticPrefs::network_dns_use_https_rr_as_altsvc()) {
+    Unused << sDNSService->CancelAsyncResolveNative(
+        NS_ConvertUTF16toUTF8(hostname), nsIDNSService::RESOLVE_TYPE_HTTPSSVC,
+        flags | nsIDNSService::RESOLVE_SPECULATE,
+        nullptr,  // AdditionalInfo
+        sDNSListener, aReason, aPartitionedPrincipalOriginAttributes);
+  }
+  return rv;
+}
+
+nsresult HTMLDNSPrefetch::CancelPrefetch(
+    const nsAString& hostname, bool isHttps,
+    const OriginAttributes& aPartitionedPrincipalOriginAttributes,
+    nsIRequest::TRRMode aTRRMode, Priority aPriority, nsresult aReason) {
+  return CancelPrefetch(hostname, isHttps,
+                        aPartitionedPrincipalOriginAttributes,
+                        nsIDNSService::GetFlagsFromTRRMode(aTRRMode) |
+                            PriorityToDNSServiceFlags(aPriority),
+                        aReason);
+}
+
+void HTMLDNSPrefetch::ElementDestroyed(Element& aElement,
+                                       SupportsDNSPrefetch& aSupports) {
+  MOZ_ASSERT(&ToSupportsDNSPrefetch(aElement) == &aSupports);
+  MOZ_ASSERT(aSupports.IsInDNSPrefetch());
+  if (sPrefetches) {
+    // Clean up all the possible links at once.
+    sPrefetches->RemoveUnboundLinks();
+  }
+}
+
+void SupportsDNSPrefetch::TryDNSPrefetch(Element& aOwner) {
+  MOZ_ASSERT(aOwner.IsInComposedDoc());
+  if (HTMLDNSPrefetch::IsAllowed(aOwner.OwnerDoc())) {
+    HTMLDNSPrefetch::Prefetch(*this, aOwner, HTMLDNSPrefetch::Priority::Low);
+  }
+}
+
+void SupportsDNSPrefetch::CancelDNSPrefetch(Element& aOwner) {
+  // If prefetch was deferred, clear flag and move on
+  if (mDNSPrefetchDeferred) {
+    mDNSPrefetchDeferred = false;
+    // Else if prefetch was requested, clear flag and send cancellation
+  } else if (mDNSPrefetchRequested) {
+    mDNSPrefetchRequested = false;
+    // Possible that hostname could have changed since binding, but since this
+    // covers common cases, most DNS prefetch requests will be canceled
+    HTMLDNSPrefetch::CancelPrefetch(
+        *this, aOwner, HTMLDNSPrefetch::Priority::Low, NS_ERROR_ABORT);
+  }
+}
+
+DeferredDNSPrefetches::DeferredDNSPrefetches()
+    : mHead(0), mTail(0), mActiveLoaderCount(0), mTimerArmed(false) {
+  mTimer = NS_NewTimer();
+}
+
+DeferredDNSPrefetches::~DeferredDNSPrefetches() {
+  if (mTimerArmed) {
+    mTimerArmed = false;
+    mTimer->Cancel();
+  }
+
+  Flush();
+}
+
+NS_IMPL_ISUPPORTS(DeferredDNSPrefetches, nsIWebProgressListener,
+                  nsISupportsWeakReference, nsIObserver)
+
+void DeferredDNSPrefetches::Flush() {
+  for (; mHead != mTail; mTail = (mTail + 1) & sMaxDeferredMask) {
+    Element* element = mEntries[mTail].mElement;
+    if (element) {
+      ToSupportsDNSPrefetch(*element).ClearIsInDNSPrefetch();
+    }
+    mEntries[mTail].mElement = nullptr;
+  }
+}
+
+nsresult DeferredDNSPrefetches::Add(nsIDNSService::DNSFlags flags,
+                                    SupportsDNSPrefetch& aSupports,
+                                    Element& aElement) {
+  // The FIFO has no lock, so it can only be accessed on main thread
+  NS_ASSERTION(NS_IsMainThread(),
+               "DeferredDNSPrefetches::Add must be on main thread");
+
+  aSupports.DNSPrefetchRequestDeferred();
+
+  if (((mHead + 1) & sMaxDeferredMask) == mTail) {
+    return NS_ERROR_DNS_LOOKUP_QUEUE_FULL;
+  }
+
+  aSupports.SetIsInDNSPrefetch();
+  mEntries[mHead].mFlags = flags;
+  mEntries[mHead].mElement = &aElement;
+  mHead = (mHead + 1) & sMaxDeferredMask;
+
+  if (!mActiveLoaderCount && !mTimerArmed && mTimer) {
+    mTimerArmed = true;
+    mTimer->InitWithNamedFuncCallback(
+        Tick, this, 2000, nsITimer::TYPE_ONE_SHOT,
+        "HTMLDNSPrefetch::DeferredDNSPrefetches::Tick");
+  }
+
+  return NS_OK;
+}
+
+void DeferredDNSPrefetches::SubmitQueue() {
+  NS_ASSERTION(NS_IsMainThread(),
+               "DeferredDNSPrefetches::SubmitQueue must be on main thread");
+  if (!EnsureDNSService()) {
+    return;
+  }
+
+  for (; mHead != mTail; mTail = (mTail + 1) & sMaxDeferredMask) {
+    Element* element = mEntries[mTail].mElement;
+    if (!element) {
+      continue;
+    }
+    SubmitQueueEntry(*element, mEntries[mTail].mFlags);
+    mEntries[mTail].mElement = nullptr;
+  }
+
+  if (mTimerArmed) {
+    mTimerArmed = false;
+    mTimer->Cancel();
+  }
+}
+
+void DeferredDNSPrefetches::SubmitQueueEntry(Element& aElement,
+                                             nsIDNSService::DNSFlags aFlags) {
+  auto& supports = ToSupportsDNSPrefetch(aElement);
+  supports.ClearIsInDNSPrefetch();
+
+  // Only prefetch here if request was deferred and deferral not cancelled
+  if (!supports.IsDNSPrefetchRequestDeferred()) {
+    return;
+  }
+
+  nsIURI* uri = supports.GetURIForDNSPrefetch(aElement);
+  if (!uri) {
+    return;
+  }
+
+  nsAutoCString hostName;
+  uri->GetAsciiHost(hostName);
+  if (hostName.IsEmpty()) {
+    return;
+  }
+
+  bool isLocalResource = false;
+  nsresult rv = NS_URIChainHasFlags(
+      uri, nsIProtocolHandler::URI_IS_LOCAL_RESOURCE, &isLocalResource);
+  if (NS_FAILED(rv) || isLocalResource) {
+    return;
+  }
+
+  OriginAttributes oa;
+  StoragePrincipalHelper::GetOriginAttributesForNetworkState(
+      aElement.OwnerDoc(), oa);
+
+  bool isHttps = uri->SchemeIs("https");
+
+  if (IsNeckoChild()) {
+    // during shutdown gNeckoChild might be null
+    if (gNeckoChild) {
+      gNeckoChild->SendHTMLDNSPrefetch(NS_ConvertUTF8toUTF16(hostName), isHttps,
+                                       oa, mEntries[mTail].mFlags);
+    }
+  } else {
+    nsCOMPtr<nsICancelable> tmpOutstanding;
+
+    rv = sDNSService->AsyncResolveNative(
+        hostName, nsIDNSService::RESOLVE_TYPE_DEFAULT,
+        mEntries[mTail].mFlags | nsIDNSService::RESOLVE_SPECULATE, nullptr,
+        sDNSListener, nullptr, oa, getter_AddRefs(tmpOutstanding));
+    if (NS_FAILED(rv)) {
+      return;
+    }
+
+    // Fetch HTTPS RR if needed.
+    if (StaticPrefs::network_dns_upgrade_with_https_rr() ||
+        StaticPrefs::network_dns_use_https_rr_as_altsvc()) {
+      sDNSService->AsyncResolveNative(
+          hostName, nsIDNSService::RESOLVE_TYPE_HTTPSSVC,
+          mEntries[mTail].mFlags | nsIDNSService::RESOLVE_SPECULATE, nullptr,
+          sDNSListener, nullptr, oa, getter_AddRefs(tmpOutstanding));
+    }
+  }
+
+  // Tell element that deferred prefetch was requested.
+  supports.DNSPrefetchRequestStarted();
+}
+
+void DeferredDNSPrefetches::Activate() {
+  // Register as an observer for the document loader
+  nsCOMPtr<nsIWebProgress> progress = components::DocLoader::Service();
+  if (progress)
+    progress->AddProgressListener(this, nsIWebProgress::NOTIFY_STATE_DOCUMENT);
+
+  // Register as an observer for xpcom shutdown events so we can drop any
+  // element refs
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+  if (observerService)
+    observerService->AddObserver(this, "xpcom-shutdown", true);
+}
+
+void DeferredDNSPrefetches::RemoveUnboundLinks() {
+  uint16_t tail = mTail;
+  while (mHead != tail) {
+    Element* element = mEntries[tail].mElement;
+    if (element && !element->IsInComposedDoc()) {
+      ToSupportsDNSPrefetch(*element).ClearIsInDNSPrefetch();
+      mEntries[tail].mElement = nullptr;
+    }
+    tail = (tail + 1) & sMaxDeferredMask;
+  }
+}
+
+// nsITimer related method
+
+void DeferredDNSPrefetches::Tick(nsITimer* aTimer, void* aClosure) {
+  auto* self = static_cast<DeferredDNSPrefetches*>(aClosure);
+
+  NS_ASSERTION(NS_IsMainThread(),
+               "DeferredDNSPrefetches::Tick must be on main thread");
+  NS_ASSERTION(self->mTimerArmed, "Timer is not armed");
+
+  self->mTimerArmed = false;
+
+  // If the queue is not submitted here because there are outstanding pages
+  // being loaded, there is no need to rearm the timer as the queue will be
+  // submtited when those loads complete.
+  if (!self->mActiveLoaderCount) {
+    self->SubmitQueue();
+  }
+}
+
+//////////// nsIWebProgressListener methods
+
+NS_IMETHODIMP
+DeferredDNSPrefetches::OnStateChange(nsIWebProgress* aWebProgress,
+                                     nsIRequest* aRequest,
+                                     uint32_t progressStateFlags,
+                                     nsresult aStatus) {
+  // The FIFO has no lock, so it can only be accessed on main thread
+  NS_ASSERTION(NS_IsMainThread(),
+               "DeferredDNSPrefetches::OnStateChange must be on main thread");
+
+  if (progressStateFlags & STATE_IS_DOCUMENT) {
+    if (progressStateFlags & STATE_STOP) {
+      // Initialization may have missed a STATE_START notification, so do
+      // not go negative
+      if (mActiveLoaderCount) mActiveLoaderCount--;
+
+      if (!mActiveLoaderCount) {
+        SubmitQueue();
+      }
+    } else if (progressStateFlags & STATE_START)
+      mActiveLoaderCount++;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DeferredDNSPrefetches::OnProgressChange(nsIWebProgress* aProgress,
+                                        nsIRequest* aRequest,
+                                        int32_t curSelfProgress,
+                                        int32_t maxSelfProgress,
+                                        int32_t curTotalProgress,
+                                        int32_t maxTotalProgress) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DeferredDNSPrefetches::OnLocationChange(nsIWebProgress* aWebProgress,
+                                        nsIRequest* aRequest, nsIURI* location,
+                                        uint32_t aFlags) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DeferredDNSPrefetches::OnStatusChange(nsIWebProgress* aWebProgress,
+                                      nsIRequest* aRequest, nsresult aStatus,
+                                      const char16_t* aMessage) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DeferredDNSPrefetches::OnSecurityChange(nsIWebProgress* aWebProgress,
+                                        nsIRequest* aRequest, uint32_t aState) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DeferredDNSPrefetches::OnContentBlockingEvent(nsIWebProgress* aWebProgress,
+                                              nsIRequest* aRequest,
+                                              uint32_t aEvent) {
+  return NS_OK;
+}
+
+//////////// nsIObserver method
+
+NS_IMETHODIMP
+DeferredDNSPrefetches::Observe(nsISupports* subject, const char* topic,
+                               const char16_t* data) {
+  if (!strcmp(topic, "xpcom-shutdown")) Flush();
+
+  return NS_OK;
+}
+
+}  // namespace mozilla::dom