Restrict promo from showing on multi-page login scenarios (#6405)

Task/Issue URL: https://app.asana.com/1/137249556945/task/1210810000390746?focus=true 

### Description
Restricts the in-browser password promo prompt from showing multiple times on the same site, especially added to ensure it won't show multiples times during a multi-step login form scenario. 

If you visit another site and are offered it there, you can see it again on the original site too since we only check the last site that was offered (and only held in memory).

### Steps to test this PR
QA optional.

- [ ] Fresh install
- [ ] Visit amazon login page and tap on the email address field; verify you are prompted to import
- [ ] Tap off of the dialog to soft-dismiss it. Enter your email address and get to the password entry page. 
- [ ] Tap on the password field; verify you do not see the promo prompt
- [ ] Now visit https://fill.dev/form/login-simple. tap on the username field and verify you are shown the prompt

---
- To see the specific tasks where the Asana app for GitHub is being used, see below:
  - https://app.asana.com/0/0/1210729428247645

Author: CDRussell

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/importing/InBrowserImportPromo.kt

@@ -43,6 +43,7 @@ class RealInBrowserImportPromo @Inject constructor(
     private val neverSavedSiteRepository: NeverSavedSiteRepository,
     private val autofillFeature: AutofillFeature,
     private val webViewCapabilityChecker: WebViewCapabilityChecker,
+    private val inBrowserPromoPreviousPromptsStore: InBrowserPromoPreviousPromptsStore,
 ) : InBrowserImportPromo {
 
     override suspend fun canShowPromo(
@@ -54,6 +55,14 @@ class RealInBrowserImportPromo @Inject constructor(
                 return@withContext false
             }
 
+            if (url == null) {
+                return@withContext false
+            }
+
+            if (inBrowserPromoPreviousPromptsStore.hasPromoBeenDisplayed(url)) {
+                return@withContext false
+            }
+
             if (featureEnabled().not()) {
                 return@withContext false
             }
@@ -74,7 +83,7 @@ class RealInBrowserImportPromo @Inject constructor(
                 return@withContext false
             }
 
-            if (url != null && neverSavedSiteRepository.isInNeverSaveList(url)) {
+            if (neverSavedSiteRepository.isInNeverSaveList(url)) {
                 return@withContext false
             }
 

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/importing/InBrowserPromoPreviousPromptsStore.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2025 DuckDuckGo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.duckduckgo.autofill.impl.importing
+
+import com.duckduckgo.autofill.impl.urlmatcher.AutofillUrlMatcher
+import com.duckduckgo.common.utils.DispatcherProvider
+import com.duckduckgo.di.scopes.AppScope
+import com.squareup.anvil.annotations.ContributesBinding
+import dagger.SingleInstanceIn
+import javax.inject.Inject
+import kotlinx.coroutines.withContext
+
+@SingleInstanceIn(AppScope::class)
+@ContributesBinding(AppScope::class)
+class InMemoryInBrowserPromoPreviousPromptsStore @Inject constructor(
+    private val urlMatcher: AutofillUrlMatcher,
+    private val dispatchers: DispatcherProvider,
+) : InBrowserPromoPreviousPromptsStore {
+
+    private var previousETldPlusOneOffered: String? = null
+
+    override suspend fun recordPromoDisplayed(originalUrl: String) {
+        withContext(dispatchers.io()) {
+            val eTldPlusOne = urlMatcher.extractUrlPartsForAutofill(originalUrl).eTldPlus1 ?: return@withContext
+            previousETldPlusOneOffered = eTldPlusOne
+        }
+    }
+
+    override suspend fun hasPromoBeenDisplayed(originalUrl: String): Boolean {
+        if (previousETldPlusOneOffered == null) return false
+
+        return withContext(dispatchers.io()) {
+            val eTldPlusOne = urlMatcher.extractUrlPartsForAutofill(originalUrl).eTldPlus1 ?: return@withContext false
+            eTldPlusOne.equals(previousETldPlusOneOffered, ignoreCase = true)
+        }
+    }
+}
+
+interface InBrowserPromoPreviousPromptsStore {
+
+    suspend fun recordPromoDisplayed(originalUrl: String)
+    suspend fun hasPromoBeenDisplayed(originalUrl: String): Boolean
+}

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/importing/ResultHandlerImportPasswords.kt

@@ -39,6 +39,7 @@ class ResultHandlerImportPasswords @Inject constructor(
     private val autofillAvailableInputTypesProvider: AutofillAvailableInputTypesProvider,
     private val dispatchers: DispatcherProvider,
     private val autofillMessagePoster: AutofillMessagePoster,
+    private val previousPromoPrompts: InBrowserPromoPreviousPromptsStore,
 ) : AutofillFragmentResultsPlugin {
 
     override suspend fun processResult(
@@ -49,22 +50,27 @@ class ResultHandlerImportPasswords @Inject constructor(
         autofillCallback: AutofillEventListener,
         webView: WebView?,
     ) {
-        logcat { "Autofill: processing import passwords result for tab $tabId" }
+        val originalUrl = result.getString(ImportPasswordsDialog.KEY_URL) ?: return
+        storeUrlForPromptToAvoidAskingAgain(originalUrl)
+
+        logcat { "Autofill: processing import passwords result for url=$originalUrl, tab=$tabId" }
         if (result.getBoolean(ImportPasswordsDialog.KEY_IMPORT_SUCCESS)) {
             logcat { "Autofill: refresh after import passwords success" }
-            val originalUrl = result.getString(ImportPasswordsDialog.KEY_URL)
-            if (originalUrl != null && webView != null) {
+            if (webView != null) {
                 refreshAvailableInputTypes(webView, originalUrl)
             } else {
-                logcat { "Autofill: cannot refresh available input types for url=$originalUrl (webView is null: ${webView == null})" }
+                logcat { "Autofill: cannot refresh available input types for url=$originalUrl, webView is null" }
             }
         } else {
             logcat { "Autofill: import didn't succeed; returning a 'no credential' response" }
-            val originalUrl = result.getString(ImportPasswordsDialog.KEY_URL) ?: return
             autofillCallback.onNoCredentialsChosenForAutofill(originalUrl)
         }
     }
 
+    private suspend fun storeUrlForPromptToAvoidAskingAgain(originalUrl: String) {
+        previousPromoPrompts.recordPromoDisplayed(originalUrl)
+    }
+
     private suspend fun refreshAvailableInputTypes(
         webView: WebView,
         originalUrl: String,

autofill/autofill-impl/src/test/java/com/duckduckgo/autofill/impl/importing/RealInBrowserImportPromoTest.kt

@@ -20,6 +20,7 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.Parameterized
 import org.mockito.Mockito.mock
+import org.mockito.kotlin.anyOrNull
 import org.mockito.kotlin.whenever
 
 @SuppressLint("DenyListedApi")
@@ -35,13 +36,15 @@ class RealInBrowserImportPromoParameterizedTest(
     private val autofillStore: InternalAutofillStore = mock()
     private val neverSavedSiteRepository: NeverSavedSiteRepository = mock()
     private val webViewCapabilityChecker: WebViewCapabilityChecker = mock()
+    private val inBrowserPromoPreviousPromptsStore: InBrowserPromoPreviousPromptsStore = mock()
 
     private val testee = RealInBrowserImportPromo(
         autofillStore = autofillStore,
         dispatchers = coroutineTestRule.testDispatcherProvider,
         neverSavedSiteRepository = neverSavedSiteRepository,
         autofillFeature = autofillFeature,
         webViewCapabilityChecker = webViewCapabilityChecker,
+        inBrowserPromoPreviousPromptsStore = inBrowserPromoPreviousPromptsStore,
     )
 
     @Before
@@ -56,6 +59,7 @@ class RealInBrowserImportPromoParameterizedTest(
         autofillFeature.self().setRawStoredState(State(enable = testCase.autofillFeatureEnabled))
         whenever(webViewCapabilityChecker.isSupported(WebMessageListener)).thenReturn(testCase.webViewWebMessageSupport)
         whenever(webViewCapabilityChecker.isSupported(DocumentStartJavaScript)).thenReturn(testCase.webViewDocumentStartJavascript)
+        whenever(inBrowserPromoPreviousPromptsStore.hasPromoBeenDisplayed(anyOrNull())).thenReturn(testCase.promoPreviouslyShownForUrl)
     }
 
     @Test
@@ -235,8 +239,8 @@ class RealInBrowserImportPromoParameterizedTest(
                     hasDeclinedPromo = false,
                     credentialCount = 0,
                     promoShownCount = 0,
-                    expected = true,
-                    description = "eligible: url is null, all other conditions met",
+                    expected = false,
+                    description = "ineligible: url is null",
                 ),
                 CanShowPromoTestCase(
                     credentialsAvailableForCurrentPage = true,
@@ -278,6 +282,36 @@ class RealInBrowserImportPromoParameterizedTest(
                     expected = false,
                     description = "ineligible: webview does not support DocumentStartJavaScript",
                 ),
+                CanShowPromoTestCase(
+                    credentialsAvailableForCurrentPage = false,
+                    url = EXAMPLE_URL,
+                    inBrowserPromoFeatureEnabled = true,
+                    autofillFeatureEnabled = true,
+                    hasEverImportedPasswords = false,
+                    hasDeclinedPromo = false,
+                    credentialCount = 0,
+                    promoShownCount = 0,
+                    webViewWebMessageSupport = true,
+                    webViewDocumentStartJavascript = true,
+                    promoPreviouslyShownForUrl = true,
+                    expected = false,
+                    description = "ineligible: promo previously shown for url",
+                ),
+                CanShowPromoTestCase(
+                    credentialsAvailableForCurrentPage = false,
+                    url = EXAMPLE_URL,
+                    inBrowserPromoFeatureEnabled = true,
+                    autofillFeatureEnabled = true,
+                    hasEverImportedPasswords = false,
+                    hasDeclinedPromo = false,
+                    credentialCount = 0,
+                    promoShownCount = 0,
+                    webViewWebMessageSupport = true,
+                    webViewDocumentStartJavascript = true,
+                    promoPreviouslyShownForUrl = false,
+                    expected = true,
+                    description = "eligible: promo not previously shown for url",
+                ),
             )
         }
 
@@ -301,6 +335,7 @@ data class CanShowPromoTestCase(
     val promoShownCount: Int,
     val webViewWebMessageSupport: Boolean = true,
     val webViewDocumentStartJavascript: Boolean = true,
+    val promoPreviouslyShownForUrl: Boolean = false,
     val expected: Boolean,
     val description: String,
 ) {