Bug 1572240 - Part 6: Remove nsIPermissionManager.testPermissionOriginNoSuffix; r=baku

This is now dead code which will be kept alive by the vtable,
and introduces needless overhead inside the permission manager.

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

--HG--
extra : moz-landing-system : lando

Author: Ehsan Akhgari

extensions/permissions/nsPermissionManager.cpp

@@ -770,12 +770,6 @@ nsPermissionManager::PermissionKey::CreateFromURI(nsIURI* aURI,
   return new PermissionKey(origin);
 }
 
-nsPermissionManager::PermissionKey*
-nsPermissionManager::PermissionKey::CreateFromOriginNoSuffix(
-    const nsACString& aOriginNoSuffix) {
-  return new PermissionKey(aOriginNoSuffix);
-}
-
 /**
  * Simple callback used by |AsyncClose| to trigger a treatment once
  * the database is closed.
@@ -2255,24 +2249,6 @@ nsPermissionManager::TestPermission(nsIURI* aURI, const nsACString& aType,
                               false, true);
 }
 
-NS_IMETHODIMP
-nsPermissionManager::TestPermissionOriginNoSuffix(
-    const nsACString& aOriginNoSuffix, const nsACString& aType,
-    uint32_t* aPermission) {
-  // Our caller isn't providing a type index hint, so we just pass -1 to force
-  // CommonPrepareToTestPermission to compute it for us based on aType.
-  auto preparationResult = CommonPrepareToTestPermission(
-      nullptr, -1, aType, aPermission, nsIPermissionManager::UNKNOWN_ACTION,
-      false, false, true);
-  if (preparationResult.is<nsresult>()) {
-    return preparationResult.as<nsresult>();
-  }
-
-  return CommonTestPermissionInternal(nullptr, nullptr, aOriginNoSuffix,
-                                      preparationResult.as<int32_t>(), aType,
-                                      aPermission, false, true);
-}
-
 NS_IMETHODIMP
 nsPermissionManager::TestPermissionFromWindow(mozIDOMWindow* aWindow,
                                               const nsACString& aType,
@@ -2364,13 +2340,12 @@ nsPermissionManager::GetPermissionObject(nsIPrincipal* aPrincipal,
 }
 
 nsresult nsPermissionManager::CommonTestPermissionInternal(
-    nsIPrincipal* aPrincipal, nsIURI* aURI, const nsACString& aOriginNoSuffix,
-    int32_t aTypeIndex, const nsACString& aType, uint32_t* aPermission,
-    bool aExactHostMatch, bool aIncludingSession) {
-  MOZ_ASSERT(aPrincipal || aURI || !aOriginNoSuffix.IsEmpty());
-  MOZ_ASSERT_IF(aPrincipal, !aURI && aOriginNoSuffix.IsEmpty());
-  MOZ_ASSERT_IF(aURI, !aPrincipal && aOriginNoSuffix.IsEmpty());
-  NS_ENSURE_ARG_POINTER(aPrincipal || aURI || !aOriginNoSuffix.IsEmpty());
+    nsIPrincipal* aPrincipal, nsIURI* aURI, int32_t aTypeIndex,
+    const nsACString& aType, uint32_t* aPermission, bool aExactHostMatch,
+    bool aIncludingSession) {
+  MOZ_ASSERT(aPrincipal || aURI);
+  MOZ_ASSERT_IF(aPrincipal, !aURI);
+  NS_ENSURE_ARG_POINTER(aPrincipal || aURI);
 
 #ifdef DEBUG
   {
@@ -2379,8 +2354,6 @@ nsresult nsPermissionManager::CommonTestPermissionInternal(
       if (aURI) {
         prin = mozilla::BasePrincipal::CreateContentPrincipal(
             aURI, OriginAttributes());
-      } else if (!aOriginNoSuffix.IsEmpty()) {
-        prin = mozilla::BasePrincipal::CreateContentPrincipal(aOriginNoSuffix);
       }
     }
     MOZ_ASSERT(prin);
@@ -2390,8 +2363,7 @@ nsresult nsPermissionManager::CommonTestPermissionInternal(
 
   PermissionHashKey* entry =
       aPrincipal ? GetPermissionHashKey(aPrincipal, aTypeIndex, aExactHostMatch)
-                 : GetPermissionHashKey(aURI, aOriginNoSuffix, aTypeIndex,
-                                        aExactHostMatch);
+                 : GetPermissionHashKey(aURI, aTypeIndex, aExactHostMatch);
   if (!entry || (!aIncludingSession &&
                  entry->GetPermission(aTypeIndex).mNonSessionExpireType ==
                      nsIPermissionManager::EXPIRE_SESSION)) {
@@ -2464,22 +2436,16 @@ nsPermissionManager::GetPermissionHashKey(nsIPrincipal* aPrincipal,
 // accepts host on the format "<foo>". This will perform an exact match lookup
 // as the string doesn't contain any dots.
 nsPermissionManager::PermissionHashKey*
-nsPermissionManager::GetPermissionHashKey(nsIURI* aURI,
-                                          const nsACString& aOriginNoSuffix,
-                                          uint32_t aType,
+nsPermissionManager::GetPermissionHashKey(nsIURI* aURI, uint32_t aType,
                                           bool aExactHostMatch) {
-  MOZ_ASSERT(aURI || !aOriginNoSuffix.IsEmpty());
-  MOZ_ASSERT_IF(aURI, aOriginNoSuffix.IsEmpty());
+  MOZ_ASSERT(aURI);
 
 #ifdef DEBUG
   {
     nsCOMPtr<nsIPrincipal> principal;
     nsresult rv = NS_OK;
     if (aURI) {
       rv = GetPrincipal(aURI, getter_AddRefs(principal));
-    } else {
-      principal =
-          mozilla::BasePrincipal::CreateContentPrincipal(aOriginNoSuffix);
     }
     MOZ_ASSERT_IF(NS_SUCCEEDED(rv),
                   PermissionAvailable(principal, mTypeArray[aType]));
@@ -2488,8 +2454,7 @@ nsPermissionManager::GetPermissionHashKey(nsIURI* aURI,
 
   nsresult rv;
   RefPtr<PermissionKey> key =
-      aURI ? PermissionKey::CreateFromURI(aURI, rv)
-           : PermissionKey::CreateFromOriginNoSuffix(aOriginNoSuffix);
+      aURI ? PermissionKey::CreateFromURI(aURI, rv) : nullptr;
   if (!key) {
     return nullptr;
   }
@@ -2514,9 +2479,6 @@ nsPermissionManager::GetPermissionHashKey(nsIURI* aURI,
         if (NS_WARN_IF(NS_FAILED(rv))) {
           return nullptr;
         }
-      } else {
-        principal =
-            mozilla::BasePrincipal::CreateContentPrincipal(aOriginNoSuffix);
       }
       RemoveFromPrincipal(principal, mTypeArray[aType]);
     } else if (permEntry.mPermission == nsIPermissionManager::UNKNOWN_ACTION) {
@@ -2534,15 +2496,9 @@ nsPermissionManager::GetPermissionHashKey(nsIURI* aURI,
     nsCOMPtr<nsIURI> uri;
     if (aURI) {
       uri = GetNextSubDomainURI(aURI);
-    } else {
-      nsresult rv = NS_NewURI(getter_AddRefs(uri), aOriginNoSuffix);
-      if (NS_WARN_IF(NS_FAILED(rv))) {
-        return nullptr;
-      }
-      uri = GetNextSubDomainURI(uri);
     }
     if (uri) {
-      return GetPermissionHashKey(uri, EmptyCString(), aType, aExactHostMatch);
+      return GetPermissionHashKey(uri, aType, aExactHostMatch);
     }
   }
 

extensions/permissions/nsPermissionManager.h

@@ -77,8 +77,6 @@ class nsPermissionManager final : public nsIPermissionManager,
     static PermissionKey* CreateFromPrincipal(nsIPrincipal* aPrincipal,
                                               nsresult& aResult);
     static PermissionKey* CreateFromURI(nsIURI* aURI, nsresult& aResult);
-    static PermissionKey* CreateFromOriginNoSuffix(
-        const nsACString& aOriginNoSuffix);
 
     explicit PermissionKey(const nsACString& aOrigin)
         : mOrigin(aOrigin), mHashCode(mozilla::HashString(aOrigin)) {}
@@ -327,9 +325,8 @@ class nsPermissionManager final : public nsIPermissionManager,
 
   PermissionHashKey* GetPermissionHashKey(nsIPrincipal* aPrincipal,
                                           uint32_t aType, bool aExactHostMatch);
-  PermissionHashKey* GetPermissionHashKey(nsIURI* aURI,
-                                          const nsACString& aOriginNoSuffix,
-                                          uint32_t aType, bool aExactHostMatch);
+  PermissionHashKey* GetPermissionHashKey(nsIURI* aURI, uint32_t aType,
+                                          bool aExactHostMatch);
 
   // The int32_t is the type index, the nsresult is an early bail-out return
   // code.
@@ -436,8 +433,8 @@ class nsPermissionManager final : public nsIPermissionManager,
     }
 
     return CommonTestPermissionInternal(
-        aPrincipal, nullptr, EmptyCString(), preparationResult.as<int32_t>(),
-        aType, aPermission, aExactHostMatch, aIncludingSession);
+        aPrincipal, nullptr, preparationResult.as<int32_t>(), aType,
+        aPermission, aExactHostMatch, aIncludingSession);
   }
   // If aTypeIndex is passed -1, we try to inder the type index from aType.
   nsresult CommonTestPermission(nsIURI* aURI, int32_t aTypeIndex,
@@ -453,14 +450,16 @@ class nsPermissionManager final : public nsIPermissionManager,
     }
 
     return CommonTestPermissionInternal(
-        nullptr, aURI, EmptyCString(), preparationResult.as<int32_t>(), aType,
-        aPermission, aExactHostMatch, aIncludingSession);
+        nullptr, aURI, preparationResult.as<int32_t>(), aType, aPermission,
+        aExactHostMatch, aIncludingSession);
   }
   // Only one of aPrincipal or aURI is allowed to be passed in.
-  nsresult CommonTestPermissionInternal(
-      nsIPrincipal* aPrincipal, nsIURI* aURI, const nsACString& aOriginNoSuffix,
-      int32_t aTypeIndex, const nsACString& aType, uint32_t* aPermission,
-      bool aExactHostMatch, bool aIncludingSession);
+  nsresult CommonTestPermissionInternal(nsIPrincipal* aPrincipal, nsIURI* aURI,
+                                        int32_t aTypeIndex,
+                                        const nsACString& aType,
+                                        uint32_t* aPermission,
+                                        bool aExactHostMatch,
+                                        bool aIncludingSession);
 
   nsresult OpenDatabase(nsIFile* permissionsFile);
   nsresult InitDB(bool aRemoveFile);