Bug 1620322 - Part 5: Refactor the code for calculating the permission type string to AntiTrackingUtils; r=baku

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

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

dom/base/Document.cpp

@@ -12,6 +12,7 @@
 #include "mozilla/dom/Document.h"
 #include "DocumentInlines.h"
 #include "mozilla/AntiTrackingCommon.h"
+#include "mozilla/AntiTrackingUtils.h"
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/AutoRestore.h"
 #include "mozilla/BinarySearch.h"
@@ -15784,7 +15785,7 @@ Document::AutomaticStorageAccessCanBeGranted() {
 
 bool Document::AutomaticStorageAccessCanBeGranted(nsIPrincipal* aPrincipal) {
   nsAutoCString prefix;
-  AntiTrackingCommon::CreateStoragePermissionKey(aPrincipal, prefix);
+  AntiTrackingUtils::CreateStoragePermissionKey(aPrincipal, prefix);
 
   nsPermissionManager* permManager = nsPermissionManager::GetInstance();
   if (NS_WARN_IF(!permManager)) {

dom/base/nsGlobalWindowOuter.cpp

@@ -22,6 +22,7 @@
 #include "nsISecureBrowserUI.h"
 #include "nsIWebProgressListener.h"
 #include "mozilla/AntiTrackingCommon.h"
+#include "mozilla/AntiTrackingUtils.h"
 #include "mozilla/dom/BindingUtils.h"
 #include "mozilla/dom/BrowserChild.h"
 #include "mozilla/dom/BrowsingContextBinding.h"
@@ -6867,7 +6868,7 @@ nsGlobalWindowOuter::Observe(nsISupports* aSupports, const char* aTopic,
     if (!principal) {
       return NS_OK;
     }
-    if (!AntiTrackingCommon::IsStorageAccessPermission(permission, principal)) {
+    if (!AntiTrackingUtils::IsStorageAccessPermission(permission, principal)) {
       return NS_OK;
     }
     if (!nsCRT::strcmp(aData, u"deleted")) {

toolkit/components/antitracking/AntiTrackingCommon.cpp

@@ -47,8 +47,6 @@
 #include "nsScriptSecurityManager.h"
 #include "prtime.h"
 
-#define ANTITRACKING_PERM_KEY "3rdPartyStorage"
-
 namespace mozilla {
 
 LazyLogModule gAntiTrackingLog("AntiTracking");
@@ -97,18 +95,6 @@ bool GetParentPrincipalAndTrackingOrigin(
   return true;
 };
 
-void CreatePermissionKey(const nsCString& aTrackingOrigin,
-                         nsACString& aPermissionKey) {
-  MOZ_ASSERT(aPermissionKey.IsEmpty());
-
-  static const nsLiteralCString prefix =
-      NS_LITERAL_CSTRING(ANTITRACKING_PERM_KEY "^");
-
-  aPermissionKey.SetCapacity(prefix.Length() + aTrackingOrigin.Length());
-  aPermissionKey.Append(prefix);
-  aPermissionKey.Append(aTrackingOrigin);
-}
-
 // This internal method returns ACCESS_DENY if the access is denied,
 // ACCESS_DEFAULT if unknown, some other access code if granted.
 uint32_t CheckCookiePermissionForPrincipal(
@@ -610,7 +596,8 @@ AntiTrackingCommon::AddFirstPartyStorageAccessGrantedFor(
        topLevelStoragePrincipal,
        aReason](int aAllowMode) -> RefPtr<StorageAccessGrantPromise> {
     nsAutoCString permissionKey;
-    CreatePermissionKey(trackingOrigin, permissionKey);
+    AntiTrackingUtils::CreateStoragePermissionKey(trackingOrigin,
+                                                  permissionKey);
 
     // Let's store the permission in the current parent window.
     topInnerWindow->SaveStorageAccessGranted(permissionKey);
@@ -737,7 +724,7 @@ AntiTrackingCommon::SaveFirstPartyStorageAccessGrantedForOriginOnParentProcess(
   }
 
   nsAutoCString type;
-  CreatePermissionKey(aTrackingOrigin, type);
+  AntiTrackingUtils::CreateStoragePermissionKey(aTrackingOrigin, type);
 
   LOG(
       ("Computed permission key: %s, expiry: %u, proceeding to save in the "
@@ -758,54 +745,6 @@ AntiTrackingCommon::SaveFirstPartyStorageAccessGrantedForOriginOnParentProcess(
   return FirstPartyStorageAccessGrantPromise::CreateAndResolve(rv, __func__);
 }
 
-// static
-bool AntiTrackingCommon::CreateStoragePermissionKey(nsIPrincipal* aPrincipal,
-                                                    nsACString& aKey) {
-  if (!aPrincipal) {
-    return false;
-  }
-
-  nsAutoCString origin;
-  nsresult rv = aPrincipal->GetOriginNoSuffix(origin);
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return false;
-  }
-
-  CreatePermissionKey(origin, aKey);
-  return true;
-}
-
-// static
-bool AntiTrackingCommon::IsStorageAccessPermission(nsIPermission* aPermission,
-                                                   nsIPrincipal* aPrincipal) {
-  MOZ_ASSERT(aPermission);
-  MOZ_ASSERT(aPrincipal);
-
-  // The permission key may belong either to a tracking origin on the same
-  // origin as the granted origin, or on another origin as the granted origin
-  // (for example when a tracker in a third-party context uses window.open to
-  // open another origin where that second origin would be the granted origin.)
-  // But even in the second case, the type of the permission would still be
-  // formed by concatenating the granted origin to the end of the type name
-  // (see CreatePermissionKey).  Therefore, we pass in the same argument to
-  // both tracking origin and granted origin here in order to compute the
-  // shorter permission key and will then do a prefix match on the type of the
-  // input permission to see if it is a storage access permission or not.
-  nsAutoCString permissionKey;
-  bool result = CreateStoragePermissionKey(aPrincipal, permissionKey);
-  if (NS_WARN_IF(!result)) {
-    return false;
-  }
-
-  nsAutoCString type;
-  nsresult rv = aPermission->GetType(type);
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return false;
-  }
-
-  return StringBeginsWith(type, permissionKey);
-}
-
 bool AntiTrackingCommon::IsFirstPartyStorageAccessGrantedFor(
     nsPIDOMWindowInner* aWindow, nsIURI* aURI, uint32_t* aRejectedReason) {
   MOZ_ASSERT(aWindow);
@@ -997,7 +936,7 @@ bool AntiTrackingCommon::IsFirstPartyStorageAccessGrantedFor(
   }
 
   nsAutoCString type;
-  CreatePermissionKey(trackingOrigin, type);
+  AntiTrackingUtils::CreateStoragePermissionKey(trackingOrigin, type);
 
   if (topInnerWindow->HasStorageAccessGranted(type)) {
     LOG(("Permission stored in the window. All good."));
@@ -1260,7 +1199,7 @@ bool AntiTrackingCommon::IsFirstPartyStorageAccessGrantedFor(
   }
 
   nsAutoCString type;
-  CreatePermissionKey(trackingOrigin, type);
+  AntiTrackingUtils::CreateStoragePermissionKey(trackingOrigin, type);
 
   uint32_t privateBrowsingId = 0;
   rv = channelPrincipal->GetPrivateBrowsingId(&privateBrowsingId);
@@ -1351,7 +1290,7 @@ bool AntiTrackingCommon::MaybeIsFirstPartyStorageAccessGrantedFor(
   nsIPrincipal* parentPrincipal = parentDocument->NodePrincipal();
 
   nsAutoCString type;
-  CreatePermissionKey(origin, type);
+  AntiTrackingUtils::CreateStoragePermissionKey(origin, type);
 
   return CheckAntiTrackingPermission(
       parentPrincipal, type,

toolkit/components/antitracking/AntiTrackingCommon.h

@@ -101,16 +101,6 @@ class AntiTrackingCommon final {
       ContentBlockingNotifier::StorageAccessGrantedReason aReason,
       const PerformFinalChecks& aPerformFinalChecks = nullptr);
 
-  // Given a principal, returns the storage permission key that will be used for
-  // the principal.  Returns true on success.
-  static bool CreateStoragePermissionKey(nsIPrincipal* aPrincipal,
-                                         nsACString& aKey);
-
-  // Returns true if the permission passed in is a storage access permission
-  // for the passed in principal argument.
-  static bool IsStorageAccessPermission(nsIPermission* aPermission,
-                                        nsIPrincipal* aPrincipal);
-
   static void StoreUserInteractionFor(nsIPrincipal* aPrincipal);
 
   static bool HasUserInteraction(nsIPrincipal* aPrincipal);

toolkit/components/antitracking/AntiTrackingUtils.cpp

@@ -9,9 +9,12 @@
 #include "mozilla/dom/BrowsingContext.h"
 #include "mozilla/dom/Document.h"
 #include "nsIChannel.h"
+#include "nsIPermission.h"
 #include "nsIURI.h"
 #include "nsPIDOMWindow.h"
 
+#define ANTITRACKING_PERM_KEY "3rdPartyStorage"
+
 using namespace mozilla;
 using namespace mozilla::dom;
 
@@ -58,3 +61,64 @@ already_AddRefed<nsIURI> AntiTrackingUtils::MaybeGetDocumentURIBeingLoaded(
   }
   return uriBeingLoaded.forget();
 }
+
+// static
+void AntiTrackingUtils::CreateStoragePermissionKey(
+    const nsCString& aTrackingOrigin, nsACString& aPermissionKey) {
+  MOZ_ASSERT(aPermissionKey.IsEmpty());
+
+  static const nsLiteralCString prefix =
+      NS_LITERAL_CSTRING(ANTITRACKING_PERM_KEY "^");
+
+  aPermissionKey.SetCapacity(prefix.Length() + aTrackingOrigin.Length());
+  aPermissionKey.Append(prefix);
+  aPermissionKey.Append(aTrackingOrigin);
+}
+
+// static
+bool AntiTrackingUtils::CreateStoragePermissionKey(nsIPrincipal* aPrincipal,
+                                                   nsACString& aKey) {
+  if (!aPrincipal) {
+    return false;
+  }
+
+  nsAutoCString origin;
+  nsresult rv = aPrincipal->GetOriginNoSuffix(origin);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return false;
+  }
+
+  CreateStoragePermissionKey(origin, aKey);
+  return true;
+}
+
+// static
+bool AntiTrackingUtils::IsStorageAccessPermission(nsIPermission* aPermission,
+                                                  nsIPrincipal* aPrincipal) {
+  MOZ_ASSERT(aPermission);
+  MOZ_ASSERT(aPrincipal);
+
+  // The permission key may belong either to a tracking origin on the same
+  // origin as the granted origin, or on another origin as the granted origin
+  // (for example when a tracker in a third-party context uses window.open to
+  // open another origin where that second origin would be the granted origin.)
+  // But even in the second case, the type of the permission would still be
+  // formed by concatenating the granted origin to the end of the type name
+  // (see CreatePermissionKey).  Therefore, we pass in the same argument to
+  // both tracking origin and granted origin here in order to compute the
+  // shorter permission key and will then do a prefix match on the type of the
+  // input permission to see if it is a storage access permission or not.
+  nsAutoCString permissionKey;
+  bool result = CreateStoragePermissionKey(aPrincipal, permissionKey);
+  if (NS_WARN_IF(!result)) {
+    return false;
+  }
+
+  nsAutoCString type;
+  nsresult rv = aPermission->GetType(type);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return false;
+  }
+
+  return StringBeginsWith(type, permissionKey);
+}

toolkit/components/antitracking/AntiTrackingUtils.h

@@ -8,10 +8,13 @@
 #define mozilla_antitrackingutils_h
 
 #include "mozilla/AlreadyAddRefed.h"
+#include "nsStringFwd.h"
 
 class nsPIDOMWindowInner;
 class nsPIDOMWindowOuter;
 class nsIChannel;
+class nsIPermission;
+class nsIPrincipal;
 class nsIURI;
 
 namespace mozilla {
@@ -24,6 +27,19 @@ class AntiTrackingUtils final {
   // Get the current document URI from a document channel as it is being loaded.
   static already_AddRefed<nsIURI> MaybeGetDocumentURIBeingLoaded(
       nsIChannel* aChannel);
+
+  static void CreateStoragePermissionKey(const nsCString& aTrackingOrigin,
+                                         nsACString& aPermissionKey);
+
+  // Given a principal, returns the storage permission key that will be used for
+  // the principal.  Returns true on success.
+  static bool CreateStoragePermissionKey(nsIPrincipal* aPrincipal,
+                                         nsACString& aKey);
+
+  // Returns true if the permission passed in is a storage access permission
+  // for the passed in principal argument.
+  static bool IsStorageAccessPermission(nsIPermission* aPermission,
+                                        nsIPrincipal* aPrincipal);
 };
 
 }  // namespace mozilla