Merge branch 'main' into fcappelli/prev_sub_breakage

Core/CookieStorage.swift

@@ -29,23 +29,36 @@ public class CookieStorage {
     private var userDefaults: UserDefaults
 
     var cookies: [HTTPCookie] {
-
-        var storedCookies = [HTTPCookie]()
-        if let cookies = userDefaults.object(forKey: Constants.key) as? [[String: Any?]] {
-            for cookieData in cookies {
-                var properties = [HTTPCookiePropertyKey: Any]()
-                cookieData.forEach({
-                    properties[HTTPCookiePropertyKey(rawValue: $0.key)] = $0.value
-                })
-
-                if let cookie = HTTPCookie(properties: properties) {
-                    os_log("read cookie %s %s %s", log: .generalLog, type: .debug, cookie.domain, cookie.name, cookie.value)
-                    storedCookies.append(cookie)
+        get {
+            var storedCookies = [HTTPCookie]()
+            if let cookies = userDefaults.object(forKey: Constants.key) as? [[String: Any?]] {
+                for cookieData in cookies {
+                    var properties = [HTTPCookiePropertyKey: Any]()
+                    cookieData.forEach({
+                        properties[HTTPCookiePropertyKey(rawValue: $0.key)] = $0.value
+                    })
+
+                    if let cookie = HTTPCookie(properties: properties) {
+                        os_log("read cookie %s %s %s", log: .generalLog, type: .debug, cookie.domain, cookie.name, cookie.value)
+                        storedCookies.append(cookie)
+                    }
                 }
             }
+
+            return storedCookies
+        }
+
+        set {
+            var cookies = [[String: Any?]]()
+            newValue.forEach { cookie in
+                var mappedCookie = [String: Any?]()
+                cookie.properties?.forEach {
+                    mappedCookie[$0.key.rawValue] = $0.value
+                }
+                cookies.append(mappedCookie)
+            }
+            userDefaults.setValue(cookies, forKey: Constants.key)
         }
-
-        return storedCookies
     }
 
     public init(userDefaults: UserDefaults = UserDefaults.app) {

Core/PixelEvent.swift

@@ -399,8 +399,6 @@ extension Pixel {
 
         case cookieDeletionTimedOut
         case cookieDeletionLeftovers
-        case legacyCookieMigration
-        case legacyCookieCleanupError
 
         case cachedTabPreviewsExceedsTabCount
         case cachedTabPreviewRemovalError
@@ -439,6 +437,10 @@ extension Pixel {
         case debugCantSaveBookmarkFix
 
         case debugCannotClearObservationsDatabase
+        case debugWebsiteDataStoresNotClearedMultiple
+        case debugWebsiteDataStoresNotClearedOne
+        case debugCookieCleanupError
+
         case debugBookmarksMigratedMoreThanOnce
 
         // Return user measurement
@@ -882,8 +884,6 @@ extension Pixel.Event {
 
         case .cookieDeletionTimedOut: return "m_d_csto"
         case .cookieDeletionLeftovers: return "m_cookie_deletion_leftovers"
-        case .legacyCookieMigration: return "m_legacy_cookie_migration"
-        case .legacyCookieCleanupError: return "m_legacy_cookie_cleanup_error"
 
         case .cachedTabPreviewsExceedsTabCount: return "m_d_tpetc"
         case .cachedTabPreviewRemovalError: return "m_d_tpre"
@@ -909,8 +909,10 @@ extension Pixel.Event {
         case .debugCantSaveBookmarkFix: return "m_d_cant_save_bookmark_fix"
 
         case .debugCannotClearObservationsDatabase: return "m_d_cannot_clear_observations_database"
-
-
+        case .debugWebsiteDataStoresNotClearedMultiple: return "m_d_wkwebsitedatastoresnotcleared_multiple"
+        case .debugWebsiteDataStoresNotClearedOne: return "m_d_wkwebsitedatastoresnotcleared_one"
+        case .debugCookieCleanupError: return "m_cookie_cleanup_error"
+
         // MARK: Ad Attribution
 
         case .adAttributionGlobalAttributedRulesDoNotExist: return "m_attribution_global_attributed_rules_do_not_exist"

Core/PreserveLogins.swift

@@ -24,34 +24,18 @@ public class PreserveLogins {
     public struct Notifications {
         public static let loginDetectionStateChanged = Foundation.Notification.Name("com.duckduckgo.ios.PreserveLogins.loginDetectionStateChanged")
     }
-
-    struct Keys {
-        static let legacyDetectedDomains = "com.duckduckgo.ios.PreserveLogins.userDecision.detectedDomains"
-        static let legacyUserDecision = "com.duckduckgo.ios.PreserveLogins.userDecision"
-        static let legacyUserPrompted = "com.duckduckgo.ios.PreserveLogins.userPrompted"
-        static let legacyAllowedDomains = UserDefaultsWrapper<Any>.Key.preserveLoginsLegacyAllowedDomains.rawValue
-    }
 
     public static let shared = PreserveLogins()
 
     @UserDefaultsWrapper(key: .preserveLoginsAllowedDomains, defaultValue: [])
     private(set) public var allowedDomains: [String]
 
-    @UserDefaultsWrapper(key: .preserveLoginsLegacyAllowedDomains, defaultValue: [])
-    private(set) public var legacyAllowedDomains: [String]
-
     @UserDefaultsWrapper(key: .preserveLoginsDetectionEnabled, defaultValue: false)
     public var loginDetectionEnabled: Bool {
         didSet {
             NotificationCenter.default.post(name: Notifications.loginDetectionStateChanged, object: nil)
         }
     }
-
-    init() {
-        UserDefaults.app.removeObject(forKey: Keys.legacyUserDecision)
-        UserDefaults.app.removeObject(forKey: Keys.legacyUserPrompted)
-        UserDefaults.app.removeObject(forKey: Keys.legacyDetectedDomains)
-    }
 
     public func addToAllowed(domain: String) {
         allowedDomains += [domain]
@@ -73,11 +57,6 @@ public class PreserveLogins {
         allowedDomains = []
     }
 
-    public func clearLegacyAllowedDomains() {
-        // This doesn't get cleared in init because it might need to be migrated
-        UserDefaults.app.removeObject(forKey: Keys.legacyAllowedDomains)
-    }
-
     public func isAllowed(fireproofDomain domain: String) -> Bool {
         return allowedDomains.contains(domain)
     }

Core/UserDefaultsPropertyWrapper.swift

@@ -115,6 +115,8 @@ public struct UserDefaultsWrapper<T> {
         case addressBarPosition = "com.duckduckgo.ios.addressbarposition"
         case showFullSiteAddress = "com.duckduckgo.ios.showfullsiteaddress"
 
+        case webContainerId = "com.duckduckgo.ios.webcontainer.id"
+
         case bookmarksLastGoodVersion = "com.duckduckgo.ios.bookmarksLastGoodVersion"
         case bookmarksMigrationVersion = "com.duckduckgo.ios.bookmarksMigrationVersion"
 

Core/WKWebViewConfigurationExtension.swift

@@ -21,8 +21,15 @@ import WebKit
 
 extension WKWebViewConfiguration {
 
-    public static func persistent() -> WKWebViewConfiguration {
-        return configuration(persistsData: true)
+    @MainActor
+    public static func persistent(idManager: DataStoreIdManager = .shared) -> WKWebViewConfiguration {
+        let config = configuration(persistsData: true)
+
+        // Only use a container if there's an id which will be allocated next time the fire button is used.
+        if #available(iOS 17, *), let containerId = idManager.id {
+            config.websiteDataStore = WKWebsiteDataStore(forIdentifier: containerId)
+        }
+        return config
     }
 
     public static func nonPersistent() -> WKWebViewConfiguration {
@@ -48,3 +55,27 @@ extension WKWebViewConfiguration {
     }
 
 }
+
+public class DataStoreIdManager {
+
+    public static let shared = DataStoreIdManager()
+
+    @UserDefaultsWrapper(key: .webContainerId, defaultValue: nil)
+    private var containerId: String?
+
+    var id: UUID? {
+        if let containerId {
+            return UUID(uuidString: containerId)
+        }
+        return nil
+    }
+
+    var hasId: Bool {
+        return containerId != nil
+    }
+
+    public func allocateNewContainerId() {
+        self.containerId = UUID().uuidString
+    }
+
+}