Bug 1943262 - Refactor instantiation of nsEffectiveTLDService r=cooki…

…e-reviewers,anti-tracking-reviewers,permissions-reviewers,emz This ensures that the instantiation of the service always returns the same singleton. I also changed calls to nsEffectiveTLDService::GetInstance to use mozilla::components::EffectiveTLD::Service() instead. Differential Revision: https://phabricator.services.mozilla.com/D235288
mozilla · Jan 28, 2025 · b8adff1 · b8adff1
1 parent 59a420a
commit b8adff1
Show file tree

Hide file tree

Showing 15 changed files with 88 additions and 71 deletions.
diff --git a/caps/BasePrincipal.cpp b/caps/BasePrincipal.cpp
@@ -30,8 +30,8 @@
 #include "mozilla/dom/StorageUtils.h"
 #include "mozilla/JSONStringWriteFuncs.h"
 #include "mozilla/JSONWriter.h"
+#include "nsIEffectiveTLDService.h"
 #include "nsIURL.h"
-#include "nsEffectiveTLDService.h"
 #include "nsIURIMutator.h"
 #include "mozilla/StaticPrefs_permissions.h"
 #include "nsIURIMutator.h"
@@ -538,7 +538,7 @@ BasePrincipal::EqualsForPermission(nsIPrincipal* aOther, bool aExactHost,
   }
 
   nsCOMPtr<nsIEffectiveTLDService> tldService =
-      do_GetService(NS_EFFECTIVETLDSERVICE_CONTRACTID);
+      mozilla::components::EffectiveTLD::Service();
   if (!tldService) {
     NS_ERROR("Should have a tld service!");
     return NS_ERROR_FAILURE;
@@ -1416,8 +1416,8 @@ BasePrincipal::GetLocalStorageQuotaKey(nsACString& aKey) {
     rv = url->GetDirectory(baseDomain);
     NS_ENSURE_SUCCESS(rv, rv);
   } else {
-    nsCOMPtr<nsIEffectiveTLDService> eTLDService(
-        do_GetService(NS_EFFECTIVETLDSERVICE_CONTRACTID, &rv));
+    nsCOMPtr<nsIEffectiveTLDService> eTLDService =
+        mozilla::components::EffectiveTLD::Service(&rv);
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsAutoCString eTLDplusOne;
@@ -1459,7 +1459,12 @@ BasePrincipal::GetNextSubDomainPrincipal(
   }
 
   nsCString subDomain;
-  rv = nsEffectiveTLDService::GetInstance()->GetNextSubDomain(host, subDomain);
+  nsCOMPtr<nsIEffectiveTLDService> eTLDService =
+      mozilla::components::EffectiveTLD::Service();
+  if (!eTLDService) {
+    return NS_OK;
+  }
+  rv = eTLDService->GetNextSubDomain(host, subDomain);
 
   if (NS_FAILED(rv) || subDomain.IsEmpty()) {
     return NS_OK;

diff --git a/dom/base/Document.cpp b/dom/base/Document.cpp
@@ -310,7 +310,6 @@
 #include "nsDeviceContext.h"
 #include "nsDocShell.h"
 #include "nsDocShellLoadTypes.h"
-#include "nsEffectiveTLDService.h"
 #include "nsError.h"
 #include "nsEscape.h"
 #include "nsFocusManager.h"
@@ -2061,7 +2060,7 @@ void Document::RecordPageLoadEventTelemetry(
   }
 
   nsCOMPtr<nsIEffectiveTLDService> tldService =
-      do_GetService(NS_EFFECTIVETLDSERVICE_CONTRACTID);
+      mozilla::components::EffectiveTLD::Service();
   if (tldService && mReferrerInfo &&
       (docshell->GetLoadType() & nsIDocShell::LOAD_CMD_NORMAL)) {
     nsAutoCString currentBaseDomain, referrerBaseDomain;
@@ -6786,7 +6785,7 @@ void Document::SetCookie(const nsAString& aCookieString, ErrorResult& aRv) {
   }
 
   nsCOMPtr<nsIEffectiveTLDService> tldService =
-      do_GetService(NS_EFFECTIVETLDSERVICE_CONTRACTID);
+      mozilla::components::EffectiveTLD::Service();
   if (!tldService) {
     return;
   }
@@ -9363,7 +9362,7 @@ bool Document::IsValidDomain(nsIURI* aOrigHost, nsIURI* aNewURI) {
     // We're golden if the new domain is the current page's base domain or a
     // subdomain of it.
     nsCOMPtr<nsIEffectiveTLDService> tldService =
-        do_GetService(NS_EFFECTIVETLDSERVICE_CONTRACTID);
+        mozilla::components::EffectiveTLD::Service();
     if (!tldService) {
       return false;
     }
@@ -18810,8 +18809,8 @@ already_AddRefed<Promise> Document::RequestStorageAccessUnderSite(
             // Get a grant for the storage access permission that will be set
             // when this is completed in the embedding context
             nsCString serializedSite;
-            RefPtr<nsEffectiveTLDService> etld =
-                nsEffectiveTLDService::GetInstance();
+            nsCOMPtr<nsIEffectiveTLDService> etld =
+                mozilla::components::EffectiveTLD::Service();
             if (!etld) {
               return StorageAccessAPIHelper::
                   StorageAccessPermissionGrantPromise::CreateAndReject(

diff --git a/dom/base/ThirdPartyUtil.cpp b/dom/base/ThirdPartyUtil.cpp
@@ -30,7 +30,6 @@
 #include "mozilla/dom/WindowGlobalParent.h"
 #include "nsCOMPtr.h"
 #include "nsDebug.h"
-#include "nsEffectiveTLDService.h"
 #include "nsError.h"
 #include "nsGlobalWindowOuter.h"
 #include "nsIChannel.h"
@@ -79,7 +78,7 @@ nsresult ThirdPartyUtil::Init() {
   gService = this;
   mozilla::ClearOnShutdown(&gService);
 
-  mTLDService = nsEffectiveTLDService::GetInstance();
+  mTLDService = mozilla::components::EffectiveTLD::Service();
   return mTLDService ? NS_OK : NS_ERROR_FAILURE;
 }
 

diff --git a/dom/base/ThirdPartyUtil.h b/dom/base/ThirdPartyUtil.h
@@ -11,6 +11,7 @@
 #include "ErrorList.h"
 #include "mozIThirdPartyUtil.h"
 #include "mozilla/RefPtr.h"
+#include "nsIEffectiveTLDService.h"
 #include "nsISupports.h"
 #include "nsString.h"
 
@@ -49,7 +50,7 @@ class ThirdPartyUtil final : public mozIThirdPartyUtil {
   nsresult IsThirdPartyInternal(const nsCString& aFirstDomain,
                                 nsIURI* aSecondURI, bool* aResult);
 
-  RefPtr<nsEffectiveTLDService> mTLDService;
+  RefPtr<nsIEffectiveTLDService> mTLDService;
 };
 
 #endif
diff --git a/dom/credentialmanagement/identity/IdentityCredential.cpp b/dom/credentialmanagement/identity/IdentityCredential.cpp
@@ -17,8 +17,8 @@
 #include "mozilla/ExpandedPrincipal.h"
 #include "mozilla/IdentityCredentialRequestManager.h"
 #include "mozilla/NullPrincipal.h"
-#include "nsEffectiveTLDService.h"
 #include "nsICredentialChooserService.h"
+#include "nsIEffectiveTLDService.h"
 #include "nsIGlobalObject.h"
 #include "nsIIdentityCredentialPromptService.h"
 #include "nsIIdentityCredentialStorageService.h"
@@ -1200,7 +1200,8 @@ IdentityCredential::CheckRootManifest(nsIPrincipal* aPrincipal,
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return IdentityCredential::ValidationPromise::CreateAndReject(rv, __func__);
   }
-  RefPtr<nsEffectiveTLDService> etld = nsEffectiveTLDService::GetInstance();
+  RefPtr<nsIEffectiveTLDService> etld =
+      mozilla::components::EffectiveTLD::Service();
   if (!etld) {
     return IdentityCredential::ValidationPromise::CreateAndReject(
         NS_ERROR_SERVICE_NOT_AVAILABLE, __func__);

diff --git a/extensions/permissions/PermissionManager.cpp b/extensions/permissions/PermissionManager.cpp
@@ -11,6 +11,7 @@
 #endif
 #include "mozilla/BasePrincipal.h"
 #include "mozilla/ClearOnShutdown.h"
+#include "mozilla/Components.h"
 #include "mozilla/ContentPrincipal.h"
 #include "mozilla/DebugOnly.h"
 #include "mozilla/dom/CanonicalBrowsingContext.h"
@@ -36,8 +37,8 @@
 #include "nsContentUtils.h"
 #include "nsCRT.h"
 #include "nsDebug.h"
-#include "nsEffectiveTLDService.h"
 #include "nsIConsoleService.h"
+#include "nsIEffectiveTLDService.h"
 #include "nsIUserIdleService.h"
 #include "nsIInputStream.h"
 #include "nsINavHistoryService.h"
@@ -250,7 +251,8 @@ nsresult GetOriginFromPrincipal(nsIPrincipal* aPrincipal, bool aForceStripOA,
 nsresult GetSiteFromPrincipal(nsIPrincipal* aPrincipal, bool aForceStripOA,
                               nsACString& aSite) {
   nsCOMPtr<nsIURI> uri = aPrincipal->GetURI();
-  nsEffectiveTLDService* etld = nsEffectiveTLDService::GetInstance();
+  nsCOMPtr<nsIEffectiveTLDService> etld =
+      mozilla::components::EffectiveTLD::Service();
   NS_ENSURE_TRUE(etld, NS_ERROR_FAILURE);
   NS_ENSURE_TRUE(uri, NS_ERROR_FAILURE);
   nsresult rv = etld->GetSite(uri, aSite);
@@ -321,8 +323,9 @@ nsresult GetPrincipal(nsIURI* aURI, nsIPrincipal** aPrincipal) {
 
 nsCString GetNextSubDomainForHost(const nsACString& aHost) {
   nsCString subDomain;
-  nsresult rv =
-      nsEffectiveTLDService::GetInstance()->GetNextSubDomain(aHost, subDomain);
+  nsCOMPtr<nsIEffectiveTLDService> etld =
+      mozilla::components::EffectiveTLD::Service();
+  nsresult rv = etld->GetNextSubDomain(aHost, subDomain);
   // We can fail if there is no more subdomain or if the host can't have a
   // subdomain.
   if (NS_FAILED(rv)) {
@@ -416,8 +419,9 @@ nsresult UpgradeHostToOriginAndInsert(
 
     // Get the eTLD+1 of the domain
     nsAutoCString eTLD1;
-    rv = nsEffectiveTLDService::GetInstance()->GetBaseDomainFromHost(aHost, 0,
-                                                                     eTLD1);
+    nsCOMPtr<nsIEffectiveTLDService> etld =
+        mozilla::components::EffectiveTLD::Service();
+    rv = etld->GetBaseDomainFromHost(aHost, 0, eTLD1);
 
     if (NS_FAILED(rv)) {
       // If the lookup on the tldService for the base domain for the host
@@ -1334,6 +1338,8 @@ nsresult PermissionManager::TryInitDB(bool aRemoveFile,
             id = idStmt->AsInt32(0) + 1;
           }
 
+          nsCOMPtr<nsIEffectiveTLDService> etld =
+              mozilla::components::EffectiveTLD::Service();
           while (NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
             MigrationEntry entry;
 
@@ -1344,8 +1350,7 @@ nsresult PermissionManager::TryInitDB(bool aRemoveFile,
             }
 
             nsAutoCString eTLD1;
-            rv = nsEffectiveTLDService::GetInstance()->GetBaseDomainFromHost(
-                entry.mHost, 0, eTLD1);
+            rv = etld->GetBaseDomainFromHost(entry.mHost, 0, eTLD1);
             if (NS_SUCCEEDED(rv)) {
               // We only care about entries which the tldService can't
               // handle
@@ -1458,6 +1463,8 @@ nsresult PermissionManager::TryInitDB(bool aRemoveFile,
 
         nsTHashSet<nsCStringHashKey> deduplicationSet;
         bool hasResult;
+        nsCOMPtr<nsIEffectiveTLDService> etld =
+            mozilla::components::EffectiveTLD::Service();
         while (NS_SUCCEEDED(selectStmt->ExecuteStep(&hasResult)) && hasResult) {
           int64_t id;
           rv = selectStmt->GetInt64(0, &id);
@@ -1477,7 +1484,7 @@ nsresult PermissionManager::TryInitDB(bool aRemoveFile,
             continue;
           }
           nsCString site;
-          rv = nsEffectiveTLDService::GetInstance()->GetSite(uri, site);
+          rv = etld->GetSite(uri, site);
           if (NS_WARN_IF(NS_FAILED(rv))) {
             continue;
           }
@@ -3559,7 +3566,9 @@ nsresult PermissionManager::GetKeyForOrigin(const nsACString& aOrigin,
     nsresult rv = NS_NewURI(getter_AddRefs(uri), aKey);
     if (!NS_WARN_IF(NS_FAILED(rv))) {
       nsCString site;
-      rv = nsEffectiveTLDService::GetInstance()->GetSite(uri, site);
+      nsCOMPtr<nsIEffectiveTLDService> etld =
+          mozilla::components::EffectiveTLD::Service();
+      rv = etld->GetSite(uri, site);
       if (!NS_WARN_IF(NS_FAILED(rv))) {
         aKey = site;
       }

diff --git a/netwerk/build/components.conf b/netwerk/build/components.conf
@@ -149,9 +149,9 @@ Classes = [
         'contract_ids': ['@mozilla.org/network/effective-tld-service;1'],
         'interfaces': ['nsIEffectiveTLDService'],
         'singleton': True,
-        'type': 'nsEffectiveTLDService',
+        'type': 'nsIEffectiveTLDService',
+        'constructor': 'nsEffectiveTLDService::GetXPCOMSingleton',
         'headers': ['/netwerk/dns/nsEffectiveTLDService.h'],
-        'init_method': 'Init',
     },
     {
         'cid': '{be9a53ae-c7e9-11d3-8cda-0060b0fc14a3}',

diff --git a/netwerk/cookie/ThirdPartyCookieBlockingExceptions.cpp b/netwerk/cookie/ThirdPartyCookieBlockingExceptions.cpp
@@ -13,6 +13,7 @@
 #include "mozilla/ErrorNames.h"
 #include "mozilla/Logging.h"
 
+#include "nsIEffectiveTLDService.h"
 #include "nsIChannel.h"
 
 namespace mozilla {
@@ -100,8 +101,8 @@ bool ThirdPartyCookieBlockingExceptions::CheckExceptionForURIs(
     return false;
   }
 
-  RefPtr<nsEffectiveTLDService> eTLDService =
-      nsEffectiveTLDService::GetInstance();
+  nsCOMPtr<nsIEffectiveTLDService> eTLDService =
+      mozilla::components::EffectiveTLD::Service();
   NS_ENSURE_TRUE(eTLDService, false);
 
   nsAutoCString thirdPartySite;
@@ -130,8 +131,8 @@ bool ThirdPartyCookieBlockingExceptions::CheckExceptionForChannel(
     return false;
   }
 
-  RefPtr<nsEffectiveTLDService> eTLDService =
-      nsEffectiveTLDService::GetInstance();
+  nsCOMPtr<nsIEffectiveTLDService> eTLDService =
+      mozilla::components::EffectiveTLD::Service();
   NS_ENSURE_TRUE(eTLDService, false);
 
   nsCOMPtr<nsIURI> uri;

diff --git a/netwerk/dns/nsEffectiveTLDService.cpp b/netwerk/dns/nsEffectiveTLDService.cpp
@@ -10,6 +10,7 @@
 
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/Components.h"
+#include "mozilla/ClearOnShutdown.h"
 #include "mozilla/HashFunctions.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/ResultExtensions.h"
@@ -41,7 +42,7 @@ NS_IMPL_ISUPPORTS(nsEffectiveTLDService, nsIEffectiveTLDService,
 
 // ----------------------------------------------------------------------
 
-static nsEffectiveTLDService* gService = nullptr;
+static StaticRefPtr<nsEffectiveTLDService> gService;
 
 nsEffectiveTLDService::nsEffectiveTLDService() : mGraph(etld_dafsa::kDafsa) {}
 
@@ -52,34 +53,29 @@ nsresult nsEffectiveTLDService::Init() {
     return NS_ERROR_ALREADY_INITIALIZED;
   }
 
-  gService = this;
   RegisterWeakMemoryReporter(this);
 
   return NS_OK;
 }
 
 nsEffectiveTLDService::~nsEffectiveTLDService() {
   UnregisterWeakMemoryReporter(this);
-  // See https://bugzilla.mozilla.org/show_bug.cgi?id=1786310#c15
-  if (gService == this) {
-    gService = nullptr;
-  }
 }
 
 // static
-nsEffectiveTLDService* nsEffectiveTLDService::GetInstance() {
+already_AddRefed<nsIEffectiveTLDService>
+nsEffectiveTLDService::GetXPCOMSingleton() {
   if (gService) {
-    return gService;
+    return do_AddRef(gService);
   }
-  nsCOMPtr<nsIEffectiveTLDService> tldService;
-  tldService = mozilla::components::EffectiveTLD::Service();
-  if (!tldService) {
+  RefPtr<nsEffectiveTLDService> instance = new nsEffectiveTLDService();
+  nsresult rv = instance->Init();
+  if (NS_FAILED(rv)) {
     return nullptr;
   }
-  MOZ_ASSERT(
-      gService,
-      "gService must have been initialized in nsEffectiveTLDService::Init");
-  return gService;
+  gService = instance;
+  ClearOnShutdown(&gService);
+  return instance.forget();
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(EffectiveTLDServiceMallocSizeOf)

diff --git a/netwerk/dns/nsEffectiveTLDService.h b/netwerk/dns/nsEffectiveTLDService.h
@@ -33,7 +33,7 @@ class nsEffectiveTLDService final : public nsIEffectiveTLDService,
   nsEffectiveTLDService();
   nsresult Init();
 
-  static nsEffectiveTLDService* GetInstance();
+  static already_AddRefed<nsIEffectiveTLDService> GetXPCOMSingleton();
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
 

diff --git a/netwerk/test/browser/browser_bug1535877.js b/netwerk/test/browser/browser_bug1535877.js
@@ -1,15 +1,17 @@
 "use strict";
 
 add_task(_ => {
-  try {
-    Cc["@mozilla.org/network/effective-tld-service;1"].createInstance(
-      Ci.nsISupports
-    );
-  } catch (e) {
-    is(
-      e.result,
-      Cr.NS_ERROR_XPC_CI_RETURNED_FAILURE,
-      "Component creation as an instance fails with expected code"
-    );
-  }
+  // Check that create instance and the service getter all return the same object.
+  let etld = Cc["@mozilla.org/network/effective-tld-service;1"].createInstance(
+    Ci.nsIEffectiveTLDService
+  );
+
+  Assert.equal(etld, Services.eTLD);
+
+  // eslint-disable-next-line mozilla/use-services
+  let etld2 = Cc["@mozilla.org/network/effective-tld-service;1"].getService(
+    Ci.nsIEffectiveTLDService
+  );
+
+  Assert.equal(etld, etld2);
 });