Ensure FF check happens on io for 1st party cookie expiry work scheduling (#7081)

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

### Description
Moves the feature flag checks to `io` instead of `main`. This is
triggered from `MainProcessLifecycleObserver` so is an important hot
path for app launch / ANR prevention.

### Steps to test this PR
- QA optional
- [ ] [optional]: add a log statement to
`FirstPartyCookiesModifierWorker.doWork()` and make sure it continues to
fire with this change in place when the process is created
- [ ] [optional]: verify the `StrictMode` violation warning no longer
shows on app process creation

Co-authored-by: Craig Russell <1336281+CDRussell@users.noreply.github.com>

Author: CDRussell

cookies/cookies-impl/build.gradle

@@ -65,7 +65,7 @@ dependencies {
     testImplementation Testing.robolectric
     testImplementation CashApp.turbine
     testImplementation AndroidX.work.testing
-
+    testImplementation "androidx.lifecycle:lifecycle-runtime-testing:_"
     testImplementation project(path: ':common-test')
 
     coreLibraryDesugaring Android.tools.desugarJdkLibs

cookies/cookies-impl/src/main/java/com/duckduckgo/cookies/impl/features/firstparty/FirstPartyCookiesModifierWorker.kt

@@ -18,6 +18,7 @@ package com.duckduckgo.cookies.impl.features.firstparty
 
 import android.content.Context
 import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.lifecycleScope
 import androidx.work.BackoffPolicy
 import androidx.work.CoroutineWorker
 import androidx.work.ExistingPeriodicWorkPolicy
@@ -32,6 +33,7 @@ import com.duckduckgo.di.scopes.AppScope
 import com.duckduckgo.feature.toggles.api.FeatureToggle
 import com.squareup.anvil.annotations.ContributesMultibinding
 import dagger.SingleInstanceIn
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.TimeUnit.DAYS
@@ -64,6 +66,7 @@ class FirstPartyCookiesModifierWorker(
 class FirstPartyCookiesModifierWorkerScheduler @Inject constructor(
     private val workManager: WorkManager,
     private val toggle: FeatureToggle,
+    private val dispatchers: DispatcherProvider,
 ) : MainProcessLifecycleObserver {
 
     private val workerRequest = PeriodicWorkRequestBuilder<FirstPartyCookiesModifierWorker>(1, DAYS)
@@ -72,18 +75,22 @@ class FirstPartyCookiesModifierWorkerScheduler @Inject constructor(
         .build()
 
     override fun onStop(owner: LifecycleOwner) {
-        if (isFeatureEnabled()) {
-            workManager.enqueueUniquePeriodicWork(FIRST_PARTY_COOKIES_EXPIRE_WORKER_TAG, ExistingPeriodicWorkPolicy.REPLACE, workerRequest)
-        } else {
-            workManager.cancelAllWorkByTag(FIRST_PARTY_COOKIES_EXPIRE_WORKER_TAG)
+        owner.lifecycleScope.launch(dispatchers.io()) {
+            if (isFeatureEnabled()) {
+                workManager.enqueueUniquePeriodicWork(FIRST_PARTY_COOKIES_EXPIRE_WORKER_TAG, ExistingPeriodicWorkPolicy.REPLACE, workerRequest)
+            } else {
+                workManager.cancelAllWorkByTag(FIRST_PARTY_COOKIES_EXPIRE_WORKER_TAG)
+            }
         }
     }
 
     override fun onStart(owner: LifecycleOwner) {
-        if (isFeatureEnabled()) {
-            workManager.enqueueUniquePeriodicWork(FIRST_PARTY_COOKIES_EXPIRE_WORKER_TAG, ExistingPeriodicWorkPolicy.KEEP, workerRequest)
-        } else {
-            workManager.cancelAllWorkByTag(FIRST_PARTY_COOKIES_EXPIRE_WORKER_TAG)
+        owner.lifecycleScope.launch(dispatchers.io()) {
+            if (isFeatureEnabled()) {
+                workManager.enqueueUniquePeriodicWork(FIRST_PARTY_COOKIES_EXPIRE_WORKER_TAG, ExistingPeriodicWorkPolicy.KEEP, workerRequest)
+            } else {
+                workManager.cancelAllWorkByTag(FIRST_PARTY_COOKIES_EXPIRE_WORKER_TAG)
+            }
         }
     }
 

cookies/cookies-impl/src/test/java/com/duckduckgo/cookies/impl/features/firstparty/FirstPartyCookiesModifierWorkerSchedulerTest.kt

@@ -16,65 +16,79 @@
 
 package com.duckduckgo.cookies.impl.features.firstparty
 
-import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.Lifecycle.State.INITIALIZED
+import androidx.lifecycle.testing.TestLifecycleOwner
+import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.work.ExistingPeriodicWorkPolicy.KEEP
 import androidx.work.ExistingPeriodicWorkPolicy.REPLACE
 import androidx.work.WorkManager
+import com.duckduckgo.common.test.CoroutineTestRule
 import com.duckduckgo.cookies.api.CookiesFeatureName
 import com.duckduckgo.feature.toggles.api.FeatureToggle
+import kotlinx.coroutines.test.runTest
 import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
+import org.junit.runner.RunWith
 import org.mockito.kotlin.any
 import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 
+@RunWith(AndroidJUnit4::class)
 class FirstPartyCookiesModifierWorkerSchedulerTest {
 
     private val mockToggle: FeatureToggle = mock()
     private val mockWorkManager: WorkManager = mock()
-    private val mockOwner: LifecycleOwner = mock()
+    private val lifecycleOwner = TestLifecycleOwner(initialState = INITIALIZED)
 
     lateinit var firstPartyCookiesModifierWorkerScheduler: FirstPartyCookiesModifierWorkerScheduler
 
+    @get:Rule
+    val coroutineTestRule: CoroutineTestRule = CoroutineTestRule()
+
     @Before
     fun before() {
-        firstPartyCookiesModifierWorkerScheduler = FirstPartyCookiesModifierWorkerScheduler(mockWorkManager, mockToggle)
+        firstPartyCookiesModifierWorkerScheduler = FirstPartyCookiesModifierWorkerScheduler(
+            workManager = mockWorkManager,
+            toggle = mockToggle,
+            dispatchers = coroutineTestRule.testDispatcherProvider,
+        )
     }
 
     @Test
-    fun whenOnStopIfFeatureEnabledThenEnqueueWorkWithReplacePolicy() {
+    fun whenOnStopIfFeatureEnabledThenEnqueueWorkWithReplacePolicy() = runTest {
         whenever(mockToggle.isFeatureEnabled(CookiesFeatureName.Cookie.value)).thenReturn(true)
 
-        firstPartyCookiesModifierWorkerScheduler.onStop(mockOwner)
+        firstPartyCookiesModifierWorkerScheduler.onStop(lifecycleOwner)
 
         verify(mockWorkManager).enqueueUniquePeriodicWork(any(), eq(REPLACE), any())
     }
 
     @Test
-    fun whenOnStopIfFeatureNotEnabledThenDeleteTag() {
+    fun whenOnStopIfFeatureNotEnabledThenDeleteTag() = runTest {
         whenever(mockToggle.isFeatureEnabled(CookiesFeatureName.Cookie.value)).thenReturn(false)
 
-        firstPartyCookiesModifierWorkerScheduler.onStop(mockOwner)
+        firstPartyCookiesModifierWorkerScheduler.onStop(lifecycleOwner)
 
         verify(mockWorkManager).cancelAllWorkByTag(any())
     }
 
     @Test
-    fun whenOnStartIfFeatureEnabledThenEnqueueWorkWithKeepPolicy() {
+    fun whenOnStartIfFeatureEnabledThenEnqueueWorkWithKeepPolicy() = runTest {
         whenever(mockToggle.isFeatureEnabled(CookiesFeatureName.Cookie.value)).thenReturn(true)
 
-        firstPartyCookiesModifierWorkerScheduler.onStart(mockOwner)
+        firstPartyCookiesModifierWorkerScheduler.onStart(lifecycleOwner)
 
         verify(mockWorkManager).enqueueUniquePeriodicWork(any(), eq(KEEP), any())
     }
 
     @Test
-    fun whenOnStartIfFeatureNotEnabledThenDeleteTag() {
+    fun whenOnStartIfFeatureNotEnabledThenDeleteTag() = runTest {
         whenever(mockToggle.isFeatureEnabled(CookiesFeatureName.Cookie.value)).thenReturn(false)
 
-        firstPartyCookiesModifierWorkerScheduler.onStart(mockOwner)
+        firstPartyCookiesModifierWorkerScheduler.onStart(lifecycleOwner)
 
         verify(mockWorkManager).cancelAllWorkByTag(any())
     }