tmp: debug

firefox-ios/Storage/Rust/RustLogins.swift

@@ -605,9 +605,17 @@ public class RustLogins: LoginsProtocol, KeyManager {
     public func addLogin(login: LoginEntry) -> Deferred<Maybe<String>> {
         let deferred = Deferred<Maybe<String>>()
 
+        self.logger.log("[issam] 0 Adding login",
+                        level: .warning,
+                        category: .storage,
+                        description: "xxxx")
         queue.async {
             guard self.isOpen else {
                 let error = LoginsStoreError.UnexpectedLoginsApiError(reason: "Database is closed")
+                self.logger.log("[issam] 1 Adding login",
+                                level: .warning,
+                                category: .storage,
+                                description: error.descriptionValue)
 
                 deferred.fill(Maybe(failure: error as MaybeErrorType))
                 return
@@ -620,9 +628,17 @@ public class RustLogins: LoginsProtocol, KeyManager {
                         let id = try self.storage?.add(login: login).id
                         deferred.fill(Maybe(success: id!))
                     } catch let err as NSError {
+                        self.logger.log("[issam] 2 Error adding login",
+                                        level: .warning,
+                                        category: .storage,
+                                        description: err.localizedDescription)
                         deferred.fill(Maybe(failure: err))
                     }
                 case .failure(let err):
+                    self.logger.log("[issam] 3 Error adding login",
+                                    level: .warning,
+                                    category: .storage,
+                                    description: err.localizedDescription)
                     deferred.fill(Maybe(failure: err))
                 }
             }
@@ -937,27 +953,52 @@ public class RustLogins: LoginsProtocol, KeyManager {
         // call or the key data has been cleared from the keychain.
 
         self.hasSyncedLogins().upon { result in
+            self.logger.log("[issam]  0 getStoredKey",
+                            level: .warning,
+                            category: .storage,
+                            description: "")
             guard result.failureValue == nil else {
                 completion(.failure(result.failureValue! as NSError))
                 return
             }
+            self.logger.log("[issam]  1 getStoredKey",
+                            level: .warning,
+                            category: .storage,
+                            description: "")
 
             guard let hasLogins = result.successValue else {
                 let msg = "Failed to verify logins count before attempting to reset key"
                 completion(.failure(LoginEncryptionKeyError.dbRecordCountVerificationError(msg) as NSError))
                 return
             }
 
+             self.logger.log("[issam]  2 getStoredKey",
+                             level: .warning,
+                             category: .storage,
+                             description: "")
+
             if hasLogins {
                 // Since the key data isn't present and we have login records in
                 // the database, we both clear the database and reset the key.
                 GleanMetrics.LoginsStoreKeyRegeneration.keychainDataLost.record()
+                self.logger.log("[issam]  3 getStoredKey",
+                                level: .warning,
+                                category: .storage,
+                                description: "")
                 self.resetLoginsAndKey(rustKeys: rustKeys, completion: completion)
             } else {
                 // There are no records in the database so we don't need to wipe any
                 // existing login records. We just need to create a new key.
                 do {
+                    self.logger.log("[issam]  4 getStoredKey",
+                                    level: .warning,
+                                    category: .storage,
+                                    description: "")
                     let key = try rustKeys.createAndStoreKey()
+                    self.logger.log("[issam]  5 getStoredKey",
+                                    level: .warning,
+                                    category: .storage,
+                                    description: "\(key)")
                     completion(.success(key))
                 } catch let error as NSError {
                     completion(.failure(error))
@@ -999,7 +1040,10 @@ public class RustLogins: LoginsProtocol, KeyManager {
     public func getKey() throws -> Data {
         let rustKeys = RustLoginEncryptionKeys()
         let (key, _) = getKeychainData(rustKeys: rustKeys)
-
+        self.logger.log("[issam] 0 getKey",
+                        level: .warning,
+                        category: .storage,
+                        description: "\(key ?? "empty")")
         guard let keyData = key?.data(using: .utf8) else {
             throw LoginsStoreError.MissingKey
         }