cache site errors and assign to pages after they load (#5902)

Task/Issue URL:
https://app.asana.com/1/137249556945/project/1208671518894266/task/1209947027710700

### Description
Resolves an issue where a web view error delivered while user is
reloading the current page would overwrite local state, making it
invalid and showing wrong URL and warnings about a lack of protections.

### Steps to test this PR

- Open `amazon.com` (either from SERP or manually)
- Type in **manually** `amazon.com` and load the page multiple times.
- Verify that address bar keeps showing the correct URL (including
HTTPS) and privacy shield.
- Opening privacy dashboard should always show that protections are
active and that the site is secure.

You can also try with `abc.com`, `cnn.com` (which always should show
`edition.cnn.com`).

Author: LukasPaczos

app/src/androidTest/java/com/duckduckgo/app/browser/BrowserTabViewModelTest.kt

@@ -105,8 +105,11 @@ import com.duckduckgo.app.browser.duckplayer.DuckPlayerJSHelper
 import com.duckduckgo.app.browser.favicon.FaviconManager
 import com.duckduckgo.app.browser.favicon.FaviconSource
 import com.duckduckgo.app.browser.history.NavigationHistoryEntry
+import com.duckduckgo.app.browser.httperrors.HttpCodeSiteErrorHandler
 import com.duckduckgo.app.browser.httperrors.HttpErrorPixelName
 import com.duckduckgo.app.browser.httperrors.HttpErrorPixels
+import com.duckduckgo.app.browser.httperrors.SiteErrorHandlerKillSwitch
+import com.duckduckgo.app.browser.httperrors.StringSiteErrorHandler
 import com.duckduckgo.app.browser.logindetection.FireproofDialogsEventHandler
 import com.duckduckgo.app.browser.logindetection.LoginDetected
 import com.duckduckgo.app.browser.logindetection.NavigationAwareLoginDetector
@@ -540,6 +543,11 @@ class BrowserTabViewModelTest {
     private val defaultVisualExperimentStateFlow = MutableStateFlow(FeatureState(isAvailable = true, isEnabled = false))
     private val defaultVisualExperimentNavBarStateFlow = MutableStateFlow(FeatureState(isAvailable = true, isEnabled = false))
 
+    private val mockSiteErrorHandlerKillSwitch: SiteErrorHandlerKillSwitch = mock()
+    private val mockSiteErrorHandlerKillSwitchToggle: Toggle = mock { on { it.isEnabled() } doReturn true }
+    private val mockSiteErrorHandler: StringSiteErrorHandler = mock()
+    private val mockSiteHttpErrorHandler: HttpCodeSiteErrorHandler = mock()
+
     @Before
     fun before() = runTest {
         MockitoAnnotations.openMocks(this)
@@ -655,6 +663,8 @@ class BrowserTabViewModelTest {
             defaultVisualExperimentNavBarStateFlow,
         )
 
+        whenever(mockSiteErrorHandlerKillSwitch.self()).thenReturn(mockSiteErrorHandlerKillSwitchToggle)
+
         testee = BrowserTabViewModel(
             statisticsUpdater = mockStatisticsUpdater,
             queryUrlConverter = mockOmnibarConverter,
@@ -723,6 +733,9 @@ class BrowserTabViewModelTest {
             defaultBrowserPromptsExperiment = mockDefaultBrowserPromptsExperiment,
             swipingTabsFeature = swipingTabsFeatureProvider,
             visualDesignExperimentDataStore = mockVisualDesignExperimentDataStore,
+            siteErrorHandlerKillSwitch = mockSiteErrorHandlerKillSwitch,
+            siteErrorHandler = mockSiteErrorHandler,
+            siteHttpErrorHandler = mockSiteHttpErrorHandler,
         )
 
         testee.loadData("abc", null, false, false)
@@ -4917,7 +4930,8 @@ class BrowserTabViewModelTest {
     }
 
     @Test
-    fun whenPageIsChangedWithHttpErrorThenPrivacyProtectionsPopupManagerIsNotified() = runTest {
+    fun whenErrorHandlerKilledAndPageIsChangedWithHttpErrorThenPrivacyProtectionsPopupManagerIsNotified() = runTest {
+        whenever(mockSiteErrorHandlerKillSwitchToggle.isEnabled()).thenReturn(false)
         testee.recordHttpErrorCode(statusCode = 404, url = "example2.com")
 
         updateUrl(
@@ -4933,6 +4947,26 @@ class BrowserTabViewModelTest {
         )
     }
 
+    @Test
+    fun whenPageIsChangedWithHttpErrorThenPrivacyProtectionsPopupManagerIsNotified() = runTest {
+        val siteCaptor = argumentCaptor<Site>()
+        whenever(mockSiteHttpErrorHandler.assignErrorsAndClearCache(siteCaptor.capture())).then {
+            siteCaptor.lastValue.onHttpErrorDetected(404)
+        }
+
+        updateUrl(
+            originalUrl = "example.com",
+            currentUrl = "example2.com",
+            isBrowserShowing = true,
+        )
+
+        verify(mockPrivacyProtectionsPopupManager).onPageLoaded(
+            url = "example2.com",
+            httpErrorCodes = listOf(404),
+            hasBrowserError = false,
+        )
+    }
+
     @Test
     fun whenPageIsChangedWithHttpError400ThenUpdateCountPixelCalledForWebViewReceivedHttpError400Daily() = runTest {
         testee.recordHttpErrorCode(statusCode = 400, url = "example2.com")
@@ -6085,6 +6119,66 @@ class BrowserTabViewModelTest {
         verify(mockPixel).fire(ONBOARDING_DAX_CTA_DISMISS_BUTTON, mapOf(PixelParameter.CTA_SHOWN to DAX_SERP_CTA))
     }
 
+    @Test
+    fun whenRecordErrorCodeThenProvideValueToErrorHandler() {
+        val site = givenCurrentSite("some.domain")
+        val siteCaptor = argumentCaptor<Site>()
+        val errorUrl = "some.domain"
+        val errorValue = "error value"
+
+        testee.recordErrorCode(url = errorUrl, error = errorValue)
+
+        verify(mockSiteErrorHandler).handleError(currentSite = siteCaptor.capture(), urlWithError = eq(errorUrl), error = eq(errorValue))
+        assertEquals(site.url, siteCaptor.lastValue.url)
+    }
+
+    @Test
+    fun whenRecordHttpErrorCodeThenProvideValueToErrorHandler() {
+        val site = givenCurrentSite("some.domain")
+        val siteCaptor = argumentCaptor<Site>()
+        val errorUrl = "some.domain"
+        val errorValue = -1
+
+        testee.recordHttpErrorCode(url = errorUrl, statusCode = errorValue)
+
+        verify(mockSiteHttpErrorHandler).handleError(currentSite = siteCaptor.capture(), urlWithError = eq(errorUrl), error = eq(errorValue))
+        assertEquals(site.url, siteCaptor.lastValue.url)
+    }
+
+    @Test
+    fun whenRecordErrorCodeNotMatchingCurrentSiteThenProvideValueToErrorHandler() {
+        val site = givenCurrentSite("some.domain")
+        val siteCaptor = argumentCaptor<Site>()
+        val errorUrl = "error.com"
+        val errorValue = "error value"
+
+        testee.recordErrorCode(url = errorUrl, error = errorValue)
+
+        verify(mockSiteErrorHandler).handleError(currentSite = siteCaptor.capture(), urlWithError = eq(errorUrl), error = eq(errorValue))
+        assertEquals(site.url, siteCaptor.lastValue.url)
+    }
+
+    @Test
+    fun whenRecordHttpErrorCodeNotMatchingCurrentSiteThenProvideValueToErrorHandler() {
+        val site = givenCurrentSite("some.domain")
+        val siteCaptor = argumentCaptor<Site>()
+        val errorUrl = "error.com"
+        val errorValue = -1
+
+        testee.recordHttpErrorCode(url = errorUrl, statusCode = errorValue)
+
+        verify(mockSiteHttpErrorHandler).handleError(currentSite = siteCaptor.capture(), urlWithError = eq(errorUrl), error = eq(errorValue))
+        assertEquals(site.url, siteCaptor.lastValue.url)
+    }
+
+    @Test
+    fun whenSiteLoadedThenAssignCachedErrors() {
+        val site = givenCurrentSite("some.domain")
+
+        verify(mockSiteErrorHandler).assignErrorsAndClearCache(site)
+        verify(mockSiteHttpErrorHandler).assignErrorsAndClearCache(site)
+    }
+
     private fun aCredential(): LoginCredentials {
         return LoginCredentials(domain = null, username = null, password = null)
     }

app/src/main/java/com/duckduckgo/app/browser/BrowserTabViewModel.kt

@@ -178,8 +178,11 @@ import com.duckduckgo.app.browser.favicon.FaviconManager
 import com.duckduckgo.app.browser.favicon.FaviconSource.ImageFavicon
 import com.duckduckgo.app.browser.favicon.FaviconSource.UrlFavicon
 import com.duckduckgo.app.browser.history.NavigationHistoryAdapter.NavigationHistoryListener
+import com.duckduckgo.app.browser.httperrors.HttpCodeSiteErrorHandler
 import com.duckduckgo.app.browser.httperrors.HttpErrorPixelName
 import com.duckduckgo.app.browser.httperrors.HttpErrorPixels
+import com.duckduckgo.app.browser.httperrors.SiteErrorHandlerKillSwitch
+import com.duckduckgo.app.browser.httperrors.StringSiteErrorHandler
 import com.duckduckgo.app.browser.logindetection.FireproofDialogsEventHandler
 import com.duckduckgo.app.browser.logindetection.FireproofDialogsEventHandler.Event
 import com.duckduckgo.app.browser.logindetection.LoginDetected
@@ -467,6 +470,9 @@ class BrowserTabViewModel @Inject constructor(
     private val defaultBrowserPromptsExperiment: DefaultBrowserPromptsExperiment,
     private val swipingTabsFeature: SwipingTabsFeatureProvider,
     private val visualDesignExperimentDataStore: VisualDesignExperimentDataStore,
+    private val siteErrorHandlerKillSwitch: SiteErrorHandlerKillSwitch,
+    private val siteErrorHandler: StringSiteErrorHandler,
+    private val siteHttpErrorHandler: HttpCodeSiteErrorHandler,
 ) : WebViewClientListener,
     EditSavedSiteListener,
     DeleteBookmarkListener,
@@ -541,7 +547,15 @@ class BrowserTabViewModel @Inject constructor(
     )
 
     private var autoCompleteJob = ConflatedJob()
+
     private var site: Site? = null
+        set(value) {
+            field = value
+            if (siteErrorHandlerKillSwitch.self().isEnabled()) {
+                siteErrorHandler.assignErrorsAndClearCache(value)
+                siteHttpErrorHandler.assignErrorsAndClearCache(value)
+            }
+        }
     private lateinit var tabId: String
     private var webNavigationState: WebNavigationState? = null
     private var httpsUpgraded = false
@@ -3391,27 +3405,35 @@ class BrowserTabViewModel @Inject constructor(
         error: String,
         url: String,
     ) {
-        // when navigating from one page to another it can happen that errors are recorded before pageChanged etc. are
-        // called triggering a buildSite.
-        if (url != site?.url) {
-            site = siteFactory.buildSite(url = url, tabId = tabId)
+        if (siteErrorHandlerKillSwitch.self().isEnabled()) {
+            siteErrorHandler.handleError(currentSite = site, urlWithError = url, error = error)
+        } else {
+            // when navigating from one page to another it can happen that errors are recorded before pageChanged etc. are
+            // called triggering a buildSite.
+            if (url != site?.url) {
+                site = siteFactory.buildSite(url = url, tabId = tabId)
+            }
+            site?.onErrorDetected(error)
         }
         Timber.d("recordErrorCode $error in ${site?.url}")
-        site?.onErrorDetected(error)
     }
 
     override fun recordHttpErrorCode(
         statusCode: Int,
         url: String,
     ) {
-        // when navigating from one page to another it can happen that errors are recorded before pageChanged etc. are
-        // called triggering a buildSite.
-        if (url != site?.url) {
-            site = siteFactory.buildSite(url = url, tabId = tabId)
+        if (siteErrorHandlerKillSwitch.self().isEnabled()) {
+            siteHttpErrorHandler.handleError(currentSite = site, urlWithError = url, error = statusCode)
+        } else {
+            // when navigating from one page to another it can happen that errors are recorded before pageChanged etc. are
+            // called triggering a buildSite.
+            if (url != site?.url) {
+                site = siteFactory.buildSite(url = url, tabId = tabId)
+            }
+            site?.onHttpErrorDetected(statusCode)
         }
         Timber.d("recordHttpErrorCode $statusCode in ${site?.url}")
         updateHttpErrorCount(statusCode)
-        site?.onHttpErrorDetected(statusCode)
     }
 
     fun onAutofillMenuSelected() {

app/src/main/java/com/duckduckgo/app/browser/di/BrowserModule.kt

@@ -40,6 +40,10 @@ import com.duckduckgo.app.browser.duckchat.AIChatQueryDetectionFeature
 import com.duckduckgo.app.browser.favicon.FaviconPersister
 import com.duckduckgo.app.browser.favicon.FileBasedFaviconPersister
 import com.duckduckgo.app.browser.httpauth.WebViewHttpAuthStore
+import com.duckduckgo.app.browser.httperrors.HttpCodeSiteErrorHandler
+import com.duckduckgo.app.browser.httperrors.HttpCodeSiteErrorHandlerImpl
+import com.duckduckgo.app.browser.httperrors.StringSiteErrorHandler
+import com.duckduckgo.app.browser.httperrors.StringSiteErrorHandlerImpl
 import com.duckduckgo.app.browser.logindetection.*
 import com.duckduckgo.app.browser.mediaplayback.store.ALL_MIGRATIONS
 import com.duckduckgo.app.browser.mediaplayback.store.MediaPlaybackDao
@@ -367,6 +371,16 @@ class BrowserModule {
     fun provideRefreshDao(appDatabase: AppDatabase): RefreshDao {
         return appDatabase.refreshDao()
     }
+
+    @Provides
+    fun provideSiteErrorStringHandler(): StringSiteErrorHandler {
+        return StringSiteErrorHandlerImpl()
+    }
+
+    @Provides
+    fun provideSiteErrorCodeHandler(): HttpCodeSiteErrorHandler {
+        return HttpCodeSiteErrorHandlerImpl()
+    }
 }
 
 @Qualifier

app/src/main/java/com/duckduckgo/app/browser/httperrors/SiteErrorHandler.kt

@@ -0,0 +1,95 @@
+/*
+ * 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.app.browser.httperrors
+
+import com.duckduckgo.anvil.annotations.ContributesRemoteFeature
+import com.duckduckgo.app.browser.BrowserTabViewModel
+import com.duckduckgo.app.global.model.Site
+import com.duckduckgo.di.scopes.AppScope
+import com.duckduckgo.feature.toggles.api.Toggle
+import javax.inject.Inject
+
+interface SiteErrorHandler<T> {
+    fun handleError(currentSite: Site?, urlWithError: String, error: T)
+    fun assignErrorsAndClearCache(site: Site?)
+}
+
+interface StringSiteErrorHandler : SiteErrorHandler<String>
+
+interface HttpCodeSiteErrorHandler : SiteErrorHandler<Int>
+
+/**
+ * When navigating from one page to another it can happen that errors are received before [BrowserTabViewModel.pageChanged].
+ * So, a previous page is still loaded, but we are already receiving potential errors about a page that's about to be loaded.
+ * For site breakage reports, we want to include these errors as well.
+ *
+ * This class provides a [handleError] function that takes the current loaded site and the received error as parameters.
+ * If the error is generated by the current site, it's immediately assigned.
+ * If not, a temporary cache is used to hold onto errors and later assign them to a newly loaded [Site].
+ *
+ * [assignErrorsAndClearCache] should be called as soon as a new [Site] is built.
+ * The function will assign previously captured errors that match the [Site.url] and drop everything else.
+ *
+ * This means that if we encounter some intermediate errors on redirects that are not part of the target site, they won't be included in the report.
+ */
+sealed class SiteErrorHandlerImpl<T> : SiteErrorHandler<T> {
+    private val cache = mutableMapOf<String, MutableList<T>>()
+
+    override fun handleError(currentSite: Site?, urlWithError: String, error: T) {
+        if (currentSite != null && currentSite.url == urlWithError) {
+            assignError(currentSite, error)
+        } else {
+            val cachedErrorsForSite = cache.getOrPut(urlWithError) {
+                mutableListOf()
+            }
+            cachedErrorsForSite.add(error)
+        }
+    }
+
+    override fun assignErrorsAndClearCache(site: Site?) {
+        if (site != null) {
+            cache[site.url]?.forEach {
+                assignError(site, it)
+            }
+        }
+        cache.clear()
+    }
+
+    protected abstract fun assignError(site: Site, error: T)
+}
+
+class StringSiteErrorHandlerImpl @Inject constructor() : StringSiteErrorHandler, SiteErrorHandlerImpl<String>() {
+    override fun assignError(site: Site, error: String) {
+        site.onErrorDetected(error)
+    }
+}
+
+class HttpCodeSiteErrorHandlerImpl @Inject constructor() : HttpCodeSiteErrorHandler, SiteErrorHandlerImpl<Int>() {
+    override fun assignError(site: Site, error: Int) {
+        site.onHttpErrorDetected(error)
+    }
+}
+
+@ContributesRemoteFeature(
+    scope = AppScope::class,
+    featureName = "siteErrorHandlerKillSwitch",
+)
+interface SiteErrorHandlerKillSwitch {
+
+    @Toggle.DefaultValue(true)
+    fun self(): Toggle
+}