From 7d70078cd1cecb1dfaaaab0d8436653139a36d70 Mon Sep 17 00:00:00 2001
From: Dave Snabel-Caunt <dave.snabel-caunt@thetradedesk.com>
Date: Wed, 24 Jul 2024 15:10:11 +0100
Subject: [PATCH] Remove unnecessary async

---
 Sources/UID2/UID2Manager.swift | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Sources/UID2/UID2Manager.swift b/Sources/UID2/UID2Manager.swift
index 4e4aff1..42e2b6d 100644
--- a/Sources/UID2/UID2Manager.swift
+++ b/Sources/UID2/UID2Manager.swift
@@ -217,11 +217,11 @@ public final actor UID2Manager {
         }
     }
     
-    private func hasExpired(expiry: Int64) async -> Bool {
+    private func hasExpired(expiry: Int64) -> Bool {
         return expiry <= dateGenerator.now.millisecondsSince1970
     }
     
-    private func getIdentityPackage(identity: UID2Identity?) async -> IdentityPackage {
+    private func getIdentityPackage(identity: UID2Identity?) -> IdentityPackage {
                 
         guard let identity = identity else {
             return IdentityPackage(valid: false, errorMessage: "Identity not available", identity: nil, status: .noIdentity)
@@ -235,11 +235,11 @@ public final actor UID2Manager {
             return IdentityPackage(valid: false, errorMessage: "refresh_token is not available or is not valid", identity: nil, status: .invalid)
         }
         
-        if await hasExpired(expiry: identity.refreshExpires) {
+        if hasExpired(expiry: identity.refreshExpires) {
             return IdentityPackage(valid: false, errorMessage: "Identity expired, refresh expired", identity: nil, status: .refreshExpired)
         }
         
-        if await hasExpired(expiry: identity.identityExpires) {
+        if hasExpired(expiry: identity.identityExpires) {
             return IdentityPackage(valid: true, errorMessage: "Identity expired, refresh still valid", identity: identity, status: .expired)
         }
      
@@ -275,7 +275,7 @@ public final actor UID2Manager {
         }
         
         // Process Remaining IdentityStatus Options
-        let validatedIdentityPackage = await getIdentityPackage(identity: identity)
+        let validatedIdentityPackage = getIdentityPackage(identity: identity)
 
         os_log("Updating identity (Identity: %@, Status: %@)", log: log,
                validatedIdentityPackage.identity != nil ? "true" : "false",
@@ -316,13 +316,13 @@ public final actor UID2Manager {
         if let identity = identity {
             // If the identity is already suitable for a refresh, we can do so immediately. Otherwise, we will work out
             // how long it is until a refresh is required and schedule it accordingly.
-            if await hasExpired(expiry: identity.refreshFrom) {
+            if hasExpired(expiry: identity.refreshFrom) {
                 refreshJob = Task {
                     await refreshToken(identity: identity)
                 }
             } else {
                 refreshJob = Task {
-                    let delayInNanoseconds = await calculateDelay(futureCompletionTime: identity.refreshFrom)
+                    let delayInNanoseconds = calculateDelay(futureCompletionTime: identity.refreshFrom)
                     try await Task.sleep(nanoseconds: delayInNanoseconds)
                     await refreshToken(identity: identity)
                 }
@@ -343,18 +343,18 @@ public final actor UID2Manager {
             
             // If the expiration time of being able to refresh is in the future, we will schedule a job to detect if we
             // pass it. This will allow us to reevaluate our state and update accordingly.
-            if await !hasExpired(expiry: identity.refreshExpires) {
+            if !hasExpired(expiry: identity.refreshExpires) {
                 checkRefreshExpiresJob = Task {
-                    let delayInNanoseconds = await calculateDelay(futureCompletionTime: identity.refreshExpires)
+                    let delayInNanoseconds = calculateDelay(futureCompletionTime: identity.refreshExpires)
                     try await Task.sleep(nanoseconds: delayInNanoseconds)
                     os_log("Detected refresh has expired", log: log, type: .debug)
                     await validateAndSetIdentity(identity: identity, status: nil, statusText: nil)
                 }
             }
             
-            if await !hasExpired(expiry: identity.identityExpires) {
+            if !hasExpired(expiry: identity.identityExpires) {
                 checkIdentityExpiresJob = Task {
-                    let delayInNanoseconds = await calculateDelay(futureCompletionTime: identity.identityExpires)
+                    let delayInNanoseconds = calculateDelay(futureCompletionTime: identity.identityExpires)
                     try await Task.sleep(nanoseconds: delayInNanoseconds)
                     os_log("Detected identity has expired", log: log, type: .debug)
                     await validateAndSetIdentity(identity: identity, status: nil, statusText: nil)
@@ -367,7 +367,7 @@ public final actor UID2Manager {
     /// Calculate the delay that Identity Checks use
     /// - Parameter futureCompletionTime: The time in milliseconds to end the
     /// - Returns: Delay in nanonseconds (UInt64) or 0 if futureCompletionTime is less than now
-    private func calculateDelay(futureCompletionTime: Int64) async -> UInt64 {
+    private func calculateDelay(futureCompletionTime: Int64) -> UInt64 {
         let now = dateGenerator.now.millisecondsSince1970
         if futureCompletionTime < now {
             return UInt64(0)