For #24512 - Remove Event.wrapper for RecentlyClosedTabs metrics

app/src/main/java/org/mozilla/fenix/components/metrics/Event.kt

@@ -57,18 +57,6 @@ sealed class Event {
     object HistorySearchTermGroupRemoveAll : Event()
     object HistorySearchIconTapped : Event()
     object HistorySearchResultTapped : Event()
-    object RecentlyClosedTabsOpened : Event()
-    object RecentlyClosedTabsClosed : Event()
-    object RecentlyClosedTabsShowFullHistory : Event()
-    object RecentlyClosedTabsOpenTab : Event()
-    object RecentlyClosedTabsDeleteTab : Event()
-    object RecentlyClosedTabsMenuClose : Event()
-    object RecentlyClosedTabsMenuShare : Event()
-    object RecentlyClosedTabsMenuDelete : Event()
-    object RecentlyClosedTabsMenuOpenInNormalTab : Event()
-    object RecentlyClosedTabsMenuOpenInPrivateTab : Event()
-    object RecentlyClosedTabsEnterMultiselect : Event()
-    object RecentlyClosedTabsExitMultiselect : Event()
     object ReaderModeAvailable : Event()
     object ReaderModeOpened : Event()
     object ReaderModeClosed : Event()

app/src/main/java/org/mozilla/fenix/components/metrics/GleanMetricsService.kt

@@ -34,7 +34,6 @@ import org.mozilla.fenix.GleanMetrics.ReaderMode
 import org.mozilla.fenix.GleanMetrics.RecentBookmarks
 import org.mozilla.fenix.GleanMetrics.RecentSearches
 import org.mozilla.fenix.GleanMetrics.RecentTabs
-import org.mozilla.fenix.GleanMetrics.RecentlyClosedTabs
 import org.mozilla.fenix.GleanMetrics.RecentlyVisitedHomepage
 import org.mozilla.fenix.GleanMetrics.SearchTerms
 import org.mozilla.fenix.GleanMetrics.StartOnHome
@@ -222,42 +221,6 @@ private val Event.wrapper: EventWrapper<*>?
         is Event.HistorySearchResultTapped -> EventWrapper<NoExtraKeys>(
             { History.searchResultTapped.record(it) }
         )
-        is Event.RecentlyClosedTabsOpened -> EventWrapper<NoExtraKeys>(
-            { RecentlyClosedTabs.opened.record(it) }
-        )
-        is Event.RecentlyClosedTabsClosed -> EventWrapper<NoExtraKeys>(
-            { RecentlyClosedTabs.closed.record(it) }
-        )
-        is Event.RecentlyClosedTabsShowFullHistory -> EventWrapper<NoExtraKeys>(
-            { RecentlyClosedTabs.showFullHistory.record(it) }
-        )
-        is Event.RecentlyClosedTabsOpenTab -> EventWrapper<NoExtraKeys>(
-            { RecentlyClosedTabs.openTab.record(it) }
-        )
-        is Event.RecentlyClosedTabsDeleteTab -> EventWrapper<NoExtraKeys>(
-            { RecentlyClosedTabs.deleteTab.record(it) }
-        )
-        is Event.RecentlyClosedTabsMenuClose -> EventWrapper<NoExtraKeys>(
-            { RecentlyClosedTabs.menuClose.record(it) }
-        )
-        is Event.RecentlyClosedTabsMenuShare -> EventWrapper<NoExtraKeys>(
-            { RecentlyClosedTabs.menuShare.record(it) }
-        )
-        is Event.RecentlyClosedTabsMenuDelete -> EventWrapper<NoExtraKeys>(
-            { RecentlyClosedTabs.menuDelete.record(it) }
-        )
-        is Event.RecentlyClosedTabsMenuOpenInNormalTab -> EventWrapper<NoExtraKeys>(
-            { RecentlyClosedTabs.menuOpenInNormalTab.record(it) }
-        )
-        is Event.RecentlyClosedTabsMenuOpenInPrivateTab -> EventWrapper<NoExtraKeys>(
-            { RecentlyClosedTabs.menuOpenInPrivateTab.record(it) }
-        )
-        is Event.RecentlyClosedTabsEnterMultiselect -> EventWrapper<NoExtraKeys>(
-            { RecentlyClosedTabs.enterMultiselect.record(it) }
-        )
-        is Event.RecentlyClosedTabsExitMultiselect -> EventWrapper<NoExtraKeys>(
-            { RecentlyClosedTabs.exitMultiselect.record(it) }
-        )
         is Event.ReaderModeAvailable -> EventWrapper<NoExtraKeys>(
             { ReaderMode.available.record(it) }
         )

app/src/main/java/org/mozilla/fenix/library/recentlyclosed/RecentlyClosedController.kt

@@ -14,12 +14,12 @@ import mozilla.components.browser.state.store.BrowserStore
 import mozilla.components.concept.engine.prompt.ShareData
 import mozilla.components.feature.recentlyclosed.RecentlyClosedTabsStorage
 import mozilla.components.feature.tabs.TabsUseCases
+import mozilla.components.service.glean.private.NoExtras
 import org.mozilla.fenix.BrowserDirection
+import org.mozilla.fenix.GleanMetrics.RecentlyClosedTabs
 import org.mozilla.fenix.HomeActivity
 import org.mozilla.fenix.R
 import org.mozilla.fenix.browser.browsingmode.BrowsingMode
-import org.mozilla.fenix.components.metrics.Event
-import org.mozilla.fenix.components.metrics.MetricController
 
 @Suppress("TooManyFunctions")
 interface RecentlyClosedController {
@@ -35,7 +35,7 @@ interface RecentlyClosedController {
     fun handleBackPressed(): Boolean
 }
 
-@Suppress("TooManyFunctions")
+@Suppress("TooManyFunctions", "LongParameterList")
 class DefaultRecentlyClosedController(
     private val navController: NavController,
     private val browserStore: BrowserStore,
@@ -43,7 +43,6 @@ class DefaultRecentlyClosedController(
     private val recentlyClosedTabsStorage: RecentlyClosedTabsStorage,
     private val tabsUseCases: TabsUseCases,
     private val activity: HomeActivity,
-    private val metrics: MetricController,
     private val lifecycleScope: CoroutineScope,
     private val openToBrowser: (url: String, mode: BrowsingMode?) -> Unit
 ) : RecentlyClosedController {
@@ -53,9 +52,9 @@ class DefaultRecentlyClosedController(
 
     override fun handleOpen(tabs: Set<TabState>, mode: BrowsingMode?) {
         if (mode == BrowsingMode.Normal) {
-            metrics.track(Event.RecentlyClosedTabsMenuOpenInNormalTab)
+            RecentlyClosedTabs.menuOpenInNormalTab.record(NoExtras())
         } else if (mode == BrowsingMode.Private) {
-            metrics.track(Event.RecentlyClosedTabsMenuOpenInPrivateTab)
+            RecentlyClosedTabs.menuOpenInPrivateTab.record(NoExtras())
         }
         recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.DeselectAll)
         tabs.forEach { tab -> handleOpen(tab, mode) }
@@ -63,25 +62,25 @@ class DefaultRecentlyClosedController(
 
     override fun handleSelect(tab: TabState) {
         if (recentlyClosedStore.state.selectedTabs.isEmpty()) {
-            metrics.track(Event.RecentlyClosedTabsEnterMultiselect)
+            RecentlyClosedTabs.enterMultiselect.record(NoExtras())
         }
         recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.Select(tab))
     }
 
     override fun handleDeselect(tab: TabState) {
         if (recentlyClosedStore.state.selectedTabs.size == 1) {
-            metrics.track(Event.RecentlyClosedTabsExitMultiselect)
+            RecentlyClosedTabs.exitMultiselect.record(NoExtras())
         }
         recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.Deselect(tab))
     }
 
     override fun handleDelete(tab: TabState) {
-        metrics.track(Event.RecentlyClosedTabsDeleteTab)
+        RecentlyClosedTabs.deleteTab.record(NoExtras())
         browserStore.dispatch(RecentlyClosedAction.RemoveClosedTabAction(tab))
     }
 
     override fun handleDelete(tabs: Set<TabState>) {
-        metrics.track(Event.RecentlyClosedTabsMenuDelete)
+        RecentlyClosedTabs.menuDelete.record(NoExtras())
         recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.DeselectAll)
         tabs.forEach { tab ->
             browserStore.dispatch(RecentlyClosedAction.RemoveClosedTabAction(tab))
@@ -89,7 +88,7 @@ class DefaultRecentlyClosedController(
     }
 
     override fun handleNavigateToHistory() {
-        metrics.track(Event.RecentlyClosedTabsShowFullHistory)
+        RecentlyClosedTabs.showFullHistory.record(NoExtras())
         navController.navigate(
             RecentlyClosedFragmentDirections.actionGlobalHistoryFragment(),
             NavOptions.Builder().setPopUpTo(R.id.historyFragment, true).build()
@@ -97,7 +96,7 @@ class DefaultRecentlyClosedController(
     }
 
     override fun handleShare(tabs: Set<TabState>) {
-        metrics.track(Event.RecentlyClosedTabsMenuShare)
+        RecentlyClosedTabs.menuShare.record(NoExtras())
         val shareData = tabs.map { ShareData(url = it.url, title = it.title) }
         navController.navigate(
             RecentlyClosedFragmentDirections.actionGlobalShareFragment(
@@ -108,7 +107,7 @@ class DefaultRecentlyClosedController(
 
     override fun handleRestore(item: TabState) {
         lifecycleScope.launch {
-            metrics.track(Event.RecentlyClosedTabsOpenTab)
+            RecentlyClosedTabs.openTab.record(NoExtras())
             tabsUseCases.restore(item, recentlyClosedTabsStorage.engineStateStorage())
 
             browserStore.dispatch(
@@ -123,11 +122,11 @@ class DefaultRecentlyClosedController(
 
     override fun handleBackPressed(): Boolean {
         return if (recentlyClosedStore.state.selectedTabs.isNotEmpty()) {
-            metrics.track(Event.RecentlyClosedTabsExitMultiselect)
+            RecentlyClosedTabs.exitMultiselect.record(NoExtras())
             recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.DeselectAll)
             true
         } else {
-            metrics.track(Event.RecentlyClosedTabsClosed)
+            RecentlyClosedTabs.closed.record(NoExtras())
             false
         }
     }

app/src/main/java/org/mozilla/fenix/library/recentlyclosed/RecentlyClosedFragment.kt

@@ -21,13 +21,13 @@ import mozilla.components.lib.state.ext.consumeFrom
 import mozilla.components.lib.state.ext.flowScoped
 import mozilla.components.support.base.feature.UserInteractionHandler
 import mozilla.components.support.ktx.kotlinx.coroutines.flow.ifChanged
+import mozilla.telemetry.glean.private.NoExtras
 import org.mozilla.fenix.BrowserDirection
+import org.mozilla.fenix.GleanMetrics.RecentlyClosedTabs
 import org.mozilla.fenix.HomeActivity
 import org.mozilla.fenix.R
 import org.mozilla.fenix.browser.browsingmode.BrowsingMode
 import org.mozilla.fenix.components.StoreProvider
-import org.mozilla.fenix.components.metrics.Event
-import org.mozilla.fenix.components.metrics.MetricController
 import org.mozilla.fenix.databinding.FragmentRecentlyClosedTabsBinding
 import org.mozilla.fenix.ext.requireComponents
 import org.mozilla.fenix.ext.setTextColor
@@ -44,8 +44,6 @@ class RecentlyClosedFragment : LibraryPageFragment<RecoverableTab>(), UserIntera
     private lateinit var recentlyClosedInteractor: RecentlyClosedFragmentInteractor
     private lateinit var recentlyClosedController: RecentlyClosedController
 
-    private lateinit var metrics: MetricController
-
     override fun onResume() {
         super.onResume()
         showToolbar(getString(R.string.library_recently_closed_tabs))
@@ -69,7 +67,7 @@ class RecentlyClosedFragment : LibraryPageFragment<RecoverableTab>(), UserIntera
         return when (item.itemId) {
             R.id.close_history -> {
                 close()
-                metrics.track(Event.RecentlyClosedTabsMenuClose)
+                RecentlyClosedTabs.menuClose.record(NoExtras())
                 true
             }
             R.id.share_history_multi_select -> {
@@ -95,9 +93,7 @@ class RecentlyClosedFragment : LibraryPageFragment<RecoverableTab>(), UserIntera
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setHasOptionsMenu(true)
-        metrics = requireComponents.analytics.metrics.also {
-            it.track(Event.RecentlyClosedTabsOpened)
-        }
+        RecentlyClosedTabs.opened.record(NoExtras())
     }
 
     override fun onCreateView(
@@ -120,7 +116,6 @@ class RecentlyClosedFragment : LibraryPageFragment<RecoverableTab>(), UserIntera
             recentlyClosedStore = recentlyClosedFragmentStore,
             activity = activity as HomeActivity,
             tabsUseCases = requireComponents.useCases.tabsUseCases,
-            metrics = metrics,
             recentlyClosedTabsStorage = requireComponents.core.recentlyClosedTabsStorage.value,
             lifecycleScope = lifecycleScope,
             openToBrowser = ::openItem

app/src/test/java/org/mozilla/fenix/library/recentlyclosed/DefaultRecentlyClosedControllerTest.kt

@@ -8,7 +8,6 @@ import androidx.navigation.NavController
 import androidx.navigation.NavOptions
 import io.mockk.mockk
 import io.mockk.coEvery
-import io.mockk.verifyAll
 import io.mockk.clearMocks
 import io.mockk.every
 import io.mockk.verify
@@ -25,14 +24,19 @@ import mozilla.components.concept.engine.prompt.ShareData
 import mozilla.components.feature.recentlyclosed.RecentlyClosedTabsStorage
 import mozilla.components.feature.tabs.TabsUseCases
 import mozilla.components.support.test.robolectric.testContext
+import mozilla.telemetry.glean.testing.GleanTestRule
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
 import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.mozilla.fenix.GleanMetrics.RecentlyClosedTabs
 import org.mozilla.fenix.HomeActivity
 import org.mozilla.fenix.R
 import org.mozilla.fenix.browser.browsingmode.BrowsingMode
-import org.mozilla.fenix.components.metrics.Event
 import org.mozilla.fenix.components.metrics.MetricController
 import org.mozilla.fenix.ext.directionsEq
 import org.mozilla.fenix.ext.optionsEq
@@ -47,6 +51,9 @@ class DefaultRecentlyClosedControllerTest {
     private val tabsUseCases: TabsUseCases = mockk(relaxed = true)
     private val metrics: MetricController = mockk(relaxed = true)
 
+    @get:Rule
+    val gleanTestRule = GleanTestRule(testContext)
+
     @Before
     fun setUp() {
         coEvery { tabsUseCases.restore.invoke(any(), any(), true) } just Runs
@@ -93,6 +100,7 @@ class DefaultRecentlyClosedControllerTest {
                 actualBrowsingModes.add(mode)
             }
         )
+        assertFalse(RecentlyClosedTabs.menuOpenInNormalTab.testHasValue())
 
         controller.handleOpen(tabs.toSet(), BrowsingMode.Normal)
 
@@ -101,7 +109,8 @@ class DefaultRecentlyClosedControllerTest {
         assertEquals(tabs[1].url, tabUrls[1])
         assertEquals(BrowsingMode.Normal, actualBrowsingModes[0])
         assertEquals(BrowsingMode.Normal, actualBrowsingModes[1])
-        verifyAll { metrics.track(Event.RecentlyClosedTabsMenuOpenInNormalTab) }
+        assertTrue(RecentlyClosedTabs.menuOpenInNormalTab.testHasValue())
+        assertNull(RecentlyClosedTabs.menuOpenInNormalTab.testGetValue().last().extra)
         clearMocks(metrics)
 
         tabUrls.clear()
@@ -114,18 +123,23 @@ class DefaultRecentlyClosedControllerTest {
         assertEquals(tabs[1].url, tabUrls[1])
         assertEquals(BrowsingMode.Private, actualBrowsingModes[0])
         assertEquals(BrowsingMode.Private, actualBrowsingModes[1])
-        verifyAll { metrics.track(Event.RecentlyClosedTabsMenuOpenInPrivateTab) }
+        assertTrue(RecentlyClosedTabs.menuOpenInPrivateTab.testHasValue())
+        assertEquals(1, RecentlyClosedTabs.menuOpenInPrivateTab.testGetValue().size)
+        assertNull(RecentlyClosedTabs.menuOpenInPrivateTab.testGetValue().single().extra)
     }
 
     @Test
     fun `handle selecting first tab`() {
         val selectedTab = createFakeTab()
         every { recentlyClosedStore.state.selectedTabs } returns emptySet()
+        assertFalse(RecentlyClosedTabs.enterMultiselect.testHasValue())
 
         createController().handleSelect(selectedTab)
 
         verify { recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.Select(selectedTab)) }
-        verify { metrics.track(Event.RecentlyClosedTabsEnterMultiselect) }
+        assertTrue(RecentlyClosedTabs.enterMultiselect.testHasValue())
+        assertEquals(1, RecentlyClosedTabs.enterMultiselect.testGetValue().size)
+        assertNull(RecentlyClosedTabs.enterMultiselect.testGetValue().single().extra)
     }
 
     @Test
@@ -136,18 +150,21 @@ class DefaultRecentlyClosedControllerTest {
         createController().handleSelect(selectedTab)
 
         verify { recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.Select(selectedTab)) }
-        verify(exactly = 0) { metrics.track(Event.RecentlyClosedTabsEnterMultiselect) }
+        assertFalse(RecentlyClosedTabs.enterMultiselect.testHasValue())
     }
 
     @Test
     fun `handle deselect last tab`() {
         val deselectedTab = createFakeTab()
         every { recentlyClosedStore.state.selectedTabs } returns setOf(deselectedTab)
+        assertFalse(RecentlyClosedTabs.exitMultiselect.testHasValue())
 
         createController().handleDeselect(deselectedTab)
 
         verify { recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.Deselect(deselectedTab)) }
-        verify { metrics.track(Event.RecentlyClosedTabsExitMultiselect) }
+        assertTrue(RecentlyClosedTabs.exitMultiselect.testHasValue())
+        assertEquals(1, RecentlyClosedTabs.exitMultiselect.testGetValue().size)
+        assertNull(RecentlyClosedTabs.exitMultiselect.testGetValue().single().extra)
     }
 
     @Test
@@ -158,24 +175,28 @@ class DefaultRecentlyClosedControllerTest {
         createController().handleDeselect(deselectedTab)
 
         verify { recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.Deselect(deselectedTab)) }
-        verify(exactly = 0) { metrics.track(Event.RecentlyClosedTabsExitMultiselect) }
+        assertFalse(RecentlyClosedTabs.exitMultiselect.testHasValue())
     }
 
     @Test
     fun handleDelete() {
         val item: TabState = mockk(relaxed = true)
+        assertFalse(RecentlyClosedTabs.deleteTab.testHasValue())
 
         createController().handleDelete(item)
 
         verify {
             browserStore.dispatch(RecentlyClosedAction.RemoveClosedTabAction(item))
         }
-        verify { metrics.track(Event.RecentlyClosedTabsDeleteTab) }
+        assertTrue(RecentlyClosedTabs.deleteTab.testHasValue())
+        assertEquals(1, RecentlyClosedTabs.deleteTab.testGetValue().size)
+        assertNull(RecentlyClosedTabs.deleteTab.testGetValue().single().extra)
     }
 
     @Test
     fun `delete multiple tabs`() {
         val tabs = createFakeTabList(2)
+        assertFalse(RecentlyClosedTabs.menuDelete.testHasValue())
 
         createController().handleDelete(tabs.toSet())
 
@@ -183,11 +204,14 @@ class DefaultRecentlyClosedControllerTest {
             browserStore.dispatch(RecentlyClosedAction.RemoveClosedTabAction(tabs[0]))
             browserStore.dispatch(RecentlyClosedAction.RemoveClosedTabAction(tabs[1]))
         }
-        verify { metrics.track(Event.RecentlyClosedTabsMenuDelete) }
+        assertTrue(RecentlyClosedTabs.menuDelete.testHasValue())
+        assertNull(RecentlyClosedTabs.menuDelete.testGetValue().last().extra)
     }
 
     @Test
     fun handleNavigateToHistory() {
+        assertFalse(RecentlyClosedTabs.showFullHistory.testHasValue())
+
         createController().handleNavigateToHistory()
 
         verify {
@@ -198,12 +222,15 @@ class DefaultRecentlyClosedControllerTest {
                 optionsEq(NavOptions.Builder().setPopUpTo(R.id.historyFragment, true).build())
             )
         }
-        verify { metrics.track(Event.RecentlyClosedTabsShowFullHistory) }
+        assertTrue(RecentlyClosedTabs.showFullHistory.testHasValue())
+        assertEquals(1, RecentlyClosedTabs.showFullHistory.testGetValue().size)
+        assertNull(RecentlyClosedTabs.showFullHistory.testGetValue().single().extra)
     }
 
     @Test
     fun `share multiple tabs`() {
         val tabs = createFakeTabList(2)
+        assertFalse(RecentlyClosedTabs.menuShare.testHasValue())
 
         createController().handleShare(tabs.toSet())
 
@@ -216,37 +243,48 @@ class DefaultRecentlyClosedControllerTest {
                 directionsEq(RecentlyClosedFragmentDirections.actionGlobalShareFragment(data))
             )
         }
-        verify { metrics.track(Event.RecentlyClosedTabsMenuShare) }
+        assertTrue(RecentlyClosedTabs.menuShare.testHasValue())
+        assertEquals(1, RecentlyClosedTabs.menuShare.testGetValue().size)
+        assertNull(RecentlyClosedTabs.menuShare.testGetValue().single().extra)
     }
 
     @Test
     fun handleRestore() = runBlocking {
         val item: TabState = mockk(relaxed = true)
+        assertFalse(RecentlyClosedTabs.openTab.testHasValue())
 
         createController(scope = this).handleRestore(item)
 
         coVerify { tabsUseCases.restore.invoke(eq(item), any(), true) }
-        verify { metrics.track(Event.RecentlyClosedTabsOpenTab) }
+        assertTrue(RecentlyClosedTabs.openTab.testHasValue())
+        assertEquals(1, RecentlyClosedTabs.openTab.testGetValue().size)
+        assertNull(RecentlyClosedTabs.openTab.testGetValue().single().extra)
     }
 
     @Test
     fun `exist multi-select mode when back is pressed`() {
         every { recentlyClosedStore.state.selectedTabs } returns createFakeTabList(3).toSet()
+        assertFalse(RecentlyClosedTabs.exitMultiselect.testHasValue())
 
         createController().handleBackPressed()
 
         verify { recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.DeselectAll) }
-        verifyAll { metrics.track(Event.RecentlyClosedTabsExitMultiselect) }
+        assertTrue(RecentlyClosedTabs.exitMultiselect.testHasValue())
+        assertEquals(1, RecentlyClosedTabs.exitMultiselect.testGetValue().size)
+        assertNull(RecentlyClosedTabs.exitMultiselect.testGetValue().single().extra)
     }
 
     @Test
     fun `report closing the fragment when back is pressed`() {
         every { recentlyClosedStore.state.selectedTabs } returns emptySet()
+        assertFalse(RecentlyClosedTabs.closed.testHasValue())
 
         createController().handleBackPressed()
 
         verify(exactly = 0) { recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.DeselectAll) }
-        verifyAll { metrics.track(Event.RecentlyClosedTabsClosed) }
+        assertTrue(RecentlyClosedTabs.closed.testHasValue())
+        assertEquals(1, RecentlyClosedTabs.closed.testGetValue().size)
+        assertNull(RecentlyClosedTabs.closed.testGetValue().single().extra)
     }
 
     private fun createController(
@@ -260,7 +298,6 @@ class DefaultRecentlyClosedControllerTest {
             RecentlyClosedTabsStorage(testContext, mockk(), mockk()),
             tabsUseCases,
             activity,
-            metrics,
             scope,
             openToBrowser
         )