Add support for addDocumentStartJavaScript (#6600)

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

### Description
* Add support for injecting a subset of C-S-S features using
`addDocumentStartJavaScript`, keeping support for `activeExperiments`
compatible with both `addDocumentStartJavaScript` and
`evaluateJavaScript`
* C-S-S sends us a ping message so we have a reference to a reply proxy
that we store and use to send messages after a user action is initiated
on the native side
* Process messages by context, then feature, and then method
* Refactor message posting fallback mechanism
* Make scoping/instancing explicit

### Steps to test this PR
**Pre-requisites**
- [x] Install C-S-S 11.15.0
- [x] Load privacy-config from
https://duckduckgo.github.io/privacy-configuration/pr-3624/v4/android-config.json
- [x] Set version to 5.300.1 in version.properties
- [x] Add logs to
`WebViewCompatBreakageContentScopeJsMessageHandler#process` and
`WebViewCompatWebCompatMessagingPlugin#postMessage`
- [x] Enable `useNewWebCompatApis` under feature flag inventory (enabled
by default)

_Desktop mode_
- [x] Load wikipedia.org
- [x] Open menu 
- [x] Switch to desktop mode
- [x] Check desktop mode is loaded


_Breakage reporting_
- [x] Load a page
- [x] Open menu 
- [x] Check subscription with name `getBreakageReportValues` is sent,
and message with method `breakageReportResult` is received

_Disable protections_
- [x] Load http://privacy-test-pages.site/privacy-protections/gpc/
- [x] Click start test
- [x] Check:
   - [x] `top frame header  - "1"`
   - [x] `top frame JS API - true`
   - [x] `frame JS API - true`
- [x] Open menu
- [x] Click Disable Privacy Protection
- [x] Click start test
- [x] Check:
   - [x] `top frame header  - ...`
   - [x] `top frame JS API - ...`
   - [x] `frame JS API - ...`

_Feature enabled_
- [x] Enable `useNewWebCompatApis` under feature flag inventory (enabled
by default)
- [x] Open https://w3c.github.io/web-share/demos/share-files.html
- [x] Click "Share"
- [x] Dismiss native share popup
- [x] Check message displayed: "Error sharing: Abort Error: Share
canceled"

_Feature enabled_
- [x] Enable `useNewWebCompatApis` under feature flag inventory (enabled
by default)
- [x] Open http://privacy-test-pages.site/privacy-protections/gpc/
- [x] Click on "Start test"
- [x] Check `frame JS API - true`

_Feature disabled_
- [x] Disable `useNewWebCompatApis` under feature flag inventory
(enabled by default)
- [x] Open http://privacy-test-pages.site/privacy-protections/gpc/
- [x] Click on "Start test"
- [x] Check `frame JS API - ...`

_Feature enabled_
- [x] Enable `useNewWebCompatApis` under feature flag inventory (enabled
by default)
- [x] Open http://privacy-test-pages.site/privacy-protections/gpc/
- [x] Check logs for `DebugFlagGlobalHandler addDebugFlag:
fingerprintingScreenSize`

### UI changes
No UI changes

Author: CrisBarreiro

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

@@ -84,6 +84,11 @@ import com.duckduckgo.duckplayer.api.DuckPlayer.OpenDuckPlayerInNewTab.On
 import com.duckduckgo.duckplayer.api.DuckPlayer.OpenDuckPlayerInNewTab.Unavailable
 import com.duckduckgo.feature.toggles.api.Toggle
 import com.duckduckgo.history.api.NavigationHistory
+import com.duckduckgo.js.messaging.api.AddDocumentStartJavaScriptPlugin
+import com.duckduckgo.js.messaging.api.PostMessageWrapperPlugin
+import com.duckduckgo.js.messaging.api.SubscriptionEventData
+import com.duckduckgo.js.messaging.api.WebMessagingPlugin
+import com.duckduckgo.js.messaging.api.WebViewCompatMessageCallback
 import com.duckduckgo.privacy.config.api.AmpLinks
 import com.duckduckgo.subscriptions.api.Subscriptions
 import com.duckduckgo.user.agent.api.ClientBrandHintProvider
@@ -97,6 +102,7 @@ import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.runTest
+import org.json.JSONObject
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
@@ -112,6 +118,8 @@ import org.mockito.kotlin.verify
 import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.whenever
 
+private val mockToggle: Toggle = mock()
+
 class BrowserWebViewClientTest {
 
     @get:Rule
@@ -158,6 +166,10 @@ class BrowserWebViewClientTest {
     private val openInNewTabFlow: MutableSharedFlow<OpenDuckPlayerInNewTab> = MutableSharedFlow()
     private val mockUriLoadedManager: UriLoadedManager = mock()
     private val mockAndroidBrowserConfigFeature: AndroidBrowserConfigFeature = mock()
+    private val mockContentScopeExperiments: ContentScopeExperiments = mock()
+    private val fakeAddDocumentStartJavaScriptPlugins = FakeAddDocumentStartJavaScriptPluginPoint()
+    private val fakeMessagingPlugins = FakeWebMessagingPluginPoint()
+    private val fakePostMessageWrapperPlugins = FakePostMessageWrapperPluginPoint()
     private val mockAndroidFeaturesHeaderPlugin = AndroidFeaturesHeaderPlugin(
         mockDuckDuckGoUrlDetector,
         mockCustomHeaderGracePeriodChecker,
@@ -166,15 +178,13 @@ class BrowserWebViewClientTest {
         mock(),
     )
     private val mockDuckChat: DuckChat = mock()
-    private val mockContentScopeExperiments: ContentScopeExperiments = mock()
 
     @UiThreadTest
     @Before
     fun setup() = runTest {
         webView = TestWebView(context)
         whenever(mockDuckPlayer.observeShouldOpenInNewTab()).thenReturn(openInNewTabFlow)
-        val toggle: Toggle = mock()
-        whenever(mockContentScopeExperiments.getActiveExperiments()).thenReturn(listOf(toggle))
+        whenever(mockContentScopeExperiments.getActiveExperiments()).thenReturn(listOf(mockToggle))
         testee = BrowserWebViewClient(
             webViewHttpAuthStore,
             trustedCertificateStore,
@@ -208,6 +218,9 @@ class BrowserWebViewClientTest {
             mockAndroidFeaturesHeaderPlugin,
             mockDuckChat,
             mockContentScopeExperiments,
+            fakeAddDocumentStartJavaScriptPlugins,
+            fakeMessagingPlugins,
+            fakePostMessageWrapperPlugins,
         )
         testee.webViewClientListener = listener
         whenever(webResourceRequest.url).thenReturn(Uri.EMPTY)
@@ -227,11 +240,8 @@ class BrowserWebViewClientTest {
     @UiThreadTest
     @Test
     fun whenOnPageStartedCalledThenListenerNotified() = runTest {
-        val toggle: Toggle = mock()
-        whenever(mockContentScopeExperiments.getActiveExperiments()).thenReturn(listOf(toggle))
-
         testee.onPageStarted(webView, EXAMPLE_URL, null)
-        verify(listener).pageStarted(any(), eq(listOf(toggle)))
+        verify(listener).pageStarted(any(), eq(listOf(mockToggle)))
     }
 
     @UiThreadTest
@@ -333,6 +343,55 @@ class BrowserWebViewClientTest {
         assertEquals(0, jsPlugins.plugin.countStarted)
     }
 
+    @UiThreadTest
+    @Test
+    fun whenOnPageStartedThenReturnActiveExperiments() {
+        val captor = argumentCaptor<List<Toggle>>()
+        testee.onPageStarted(webView, EXAMPLE_URL, null)
+        verify(listener).pageStarted(any(), captor.capture())
+        assertTrue(captor.firstValue.contains(mockToggle))
+    }
+
+    @UiThreadTest
+    @Test
+    fun whenConfigureWebViewThenInjectJsCode() {
+        assertEquals(0, fakeAddDocumentStartJavaScriptPlugins.plugin.countInitted)
+        val mockCallback = mock<WebViewCompatMessageCallback>()
+        testee.configureWebView(DuckDuckGoWebView(context), mockCallback)
+        assertEquals(1, fakeAddDocumentStartJavaScriptPlugins.plugin.countInitted)
+    }
+
+    @UiThreadTest
+    @Test
+    fun whenConfigureWebViewThenAddWebMessageListener() {
+        assertFalse(fakeMessagingPlugins.plugin.registered)
+        val mockCallback = mock<WebViewCompatMessageCallback>()
+        testee.configureWebView(DuckDuckGoWebView(context), mockCallback)
+        assertTrue(fakeMessagingPlugins.plugin.registered)
+    }
+
+    @UiThreadTest
+    @Test
+    fun whenDestroyThenRemoveWebMessageListener() = runTest {
+        val mockCallback = mock<WebViewCompatMessageCallback>()
+        val webView = DuckDuckGoWebView(context)
+        testee.configureWebView(webView, mockCallback)
+        assertTrue(fakeMessagingPlugins.plugin.registered)
+        testee.destroy(webView)
+        assertFalse(fakeMessagingPlugins.plugin.registered)
+    }
+
+    @Test
+    fun whenPostMessageThenCallPostContentScopeMessage() = runTest {
+        val data = SubscriptionEventData("feature", "method", JSONObject())
+
+        assertFalse(fakePostMessageWrapperPlugins.plugin.postMessageCalled)
+
+        testee.postContentScopeMessage(data)
+
+        assertTrue(fakePostMessageWrapperPlugins.plugin.postMessageCalled)
+    }
+
     @UiThreadTest
     @Test
     fun whenOnReceivedHttpAuthRequestThenListenerNotified() {
@@ -1203,7 +1262,11 @@ class BrowserWebViewClientTest {
             countStarted++
         }
 
-        override fun onPageFinished(webView: WebView, url: String?, site: Site?) {
+        override fun onPageFinished(
+            webView: WebView,
+            url: String?,
+            site: Site?,
+        ) {
             countFinished++
         }
     }
@@ -1266,4 +1329,73 @@ class BrowserWebViewClientTest {
     companion object {
         const val EXAMPLE_URL = "https://example.com"
     }
+
+    class FakeAddDocumentStartJavaScriptPlugin : AddDocumentStartJavaScriptPlugin {
+
+        var countInitted = 0
+            private set
+
+        override fun addDocumentStartJavaScript(
+            webView: WebView,
+        ) {
+            countInitted++
+        }
+    }
+
+    class FakeAddDocumentStartJavaScriptPluginPoint : PluginPoint<AddDocumentStartJavaScriptPlugin> {
+
+        val plugin = FakeAddDocumentStartJavaScriptPlugin()
+
+        override fun getPlugins() = listOf(plugin)
+    }
+
+    class FakeWebMessagingPlugin : WebMessagingPlugin {
+        var registered = false
+            private set
+
+        override fun unregister(webView: WebView) {
+            registered = false
+        }
+
+        override fun register(
+            jsMessageCallback: WebViewCompatMessageCallback,
+            webView: WebView,
+        ) {
+            registered = true
+        }
+
+        override fun postMessage(subscriptionEventData: SubscriptionEventData) {
+        }
+
+        override val context: String
+            get() = "test"
+    }
+
+    class FakeWebMessagingPluginPoint : PluginPoint<WebMessagingPlugin> {
+        val plugin = FakeWebMessagingPlugin()
+
+        override fun getPlugins(): Collection<WebMessagingPlugin> {
+            return listOf(plugin)
+        }
+    }
+
+    class FakePostMessageWrapperPlugin : PostMessageWrapperPlugin {
+        var postMessageCalled = false
+            private set
+
+        override fun postMessage(message: SubscriptionEventData) {
+            postMessageCalled = true
+        }
+
+        override val context: String
+            get() = "contentScopeScripts"
+    }
+
+    class FakePostMessageWrapperPluginPoint : PluginPoint<PostMessageWrapperPlugin> {
+        val plugin = FakePostMessageWrapperPlugin()
+
+        override fun getPlugins(): Collection<PostMessageWrapperPlugin> {
+            return listOf(plugin)
+        }
+    }
 }

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

@@ -17,17 +17,28 @@
 package com.duckduckgo.app.browser
 
 import androidx.test.annotation.UiThreadTest
+import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
 import org.junit.Assert.assertFalse
+import org.junit.Before
 import org.junit.Test
+import org.junit.runner.RunWith
 
+@RunWith(AndroidJUnit4::class)
 class DuckDuckGoWebViewTest {
 
+    private lateinit var testee: DuckDuckGoWebView
+
+    @Before
+    @UiThreadTest
+    fun setUp() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        testee = DuckDuckGoWebView(context)
+    }
+
     @Test
     @UiThreadTest
     fun whenWebViewInitialisedThenSafeBrowsingDisabled() {
-        val context = InstrumentationRegistry.getInstrumentation().targetContext
-        val testee = DuckDuckGoWebView(context)
         assertFalse(testee.settings.safeBrowsingEnabled)
     }
 }