Allow users to recover from WebView renderer failures

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

@@ -117,6 +117,15 @@ class BrowserWebViewClientTest {
         verify(offlinePixelCountDataStore, times(1)).webRendererGoneKilledCount = 1
     }
 
+    @Test
+    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.O)
+    fun whenRenderProcessGoneThenEmitEventIntoListener() {
+        val detail: RenderProcessGoneDetail = mock()
+        whenever(detail.didCrash()).thenReturn(true)
+        testee.onRenderProcessGone(webView, detail)
+        verify(listener, times(1)).recoverFromRenderProcessGone()
+    }
+
     private class TestWebView(context: Context) : WebView(context)
 
     companion object {

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2019 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
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Test
+
+class EmptyNavigationStateTest {
+
+    @Test
+    fun whenEmptyNavigationStateFromNavigationStateThenBrowserPropertiesAreTheSame() {
+        val previousState = buildState("originalUrl", "currentUrl", "titlle")
+        val emptyNavigationState = EmptyNavigationState(previousState)
+
+        assertEquals(emptyNavigationState.currentUrl, previousState.currentUrl)
+        assertEquals(emptyNavigationState.originalUrl, previousState.originalUrl)
+        assertEquals(emptyNavigationState.title, previousState.title)
+    }
+
+    @Test
+    fun whenEmptyNavigationStateFromNavigationStateThenNavigationPropertiesAreCleared() {
+        val emptyNavigationState = EmptyNavigationState(buildState("originalUrl", "currentUrl", "titlle"))
+
+        assertEquals(emptyNavigationState.stepsToPreviousPage, 0)
+        assertFalse(emptyNavigationState.canGoBack)
+        assertFalse(emptyNavigationState.canGoForward)
+        assertFalse(emptyNavigationState.hasNavigationHistory)
+    }
+
+    private fun buildState(originalUrl: String?, currentUrl: String?, title: String? = null): WebNavigationState {
+        return TestNavigationState(
+            originalUrl = originalUrl,
+            currentUrl = currentUrl,
+            title = title,
+            stepsToPreviousPage = 1,
+            canGoBack = true,
+            canGoForward = true,
+            hasNavigationHistory = true
+        )
+    }
+}

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

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2019 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
+
+data class TestNavigationState(
+    override val originalUrl: String?,
+    override val currentUrl: String?,
+    override val title: String?,
+    override val stepsToPreviousPage: Int,
+    override val canGoBack: Boolean,
+    override val canGoForward: Boolean,
+    override val hasNavigationHistory: Boolean
+) : WebNavigationState

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

@@ -91,13 +91,6 @@ class WebNavigationStateComparisonTest {
         assertEquals(UrlUpdated("http://same.com/latest"), latestState.compare(previousState))
     }
 
-    @Test
-    fun whenPreviousContainsAnOriginalUrlAndCurrentUrlAndLatestContainsSameOriginalUrlAndNoCurrentUrlThenCompareReturnsOther() {
-        val previousState = buildState("http://same.com", "http://subdomain.previous.com")
-        val latestState = buildState("http://same.com", null)
-        assertEquals(Other, latestState.compare(previousState))
-    }
-
     @Test
     fun whenPreviousContainsAnOriginalUrlAndCurrentUrlAndLatestStateContainsNoOriginalUrlAndNoCurrentUrlThenCompareReturnsPageCleared() {
         val previousState = buildState("http://previous.com", "http://subdomain.previous.com")
@@ -112,6 +105,20 @@ class WebNavigationStateComparisonTest {
         assertEquals(PageCleared, latestState.compare(previousState))
     }
 
+    @Test
+    fun whenLatestStateIsEmptyNavigationCompareReturnsPageNavigationCleared() {
+        val previousState = buildState("http://previous.com", "http://subdomain.previous.com")
+        val latestState = EmptyNavigationState(previousState)
+        assertEquals(PageNavigationCleared, latestState.compare(previousState))
+    }
+
+    @Test
+    fun whenPreviousContainsAnOriginalUrlAndCurrentUrlAndLatestContainsSameOriginalUrlAndNoCurrentUrlThenCompareReturnsOther() {
+        val previousState = buildState("http://same.com", "http://subdomain.previous.com")
+        val latestState = buildState("http://same.com", null)
+        assertEquals(Other, latestState.compare(previousState))
+    }
+
     @Test
     fun whenPreviousContainsAnOriginalUrlAndCurrentUrlAndLatestStateContainsDifferentOriginalUrlAndNoCurrentUrlThenCompareReturnsOther() {
         val previousState = buildState("http://previous.com", "http://subdomain.previous.com")
@@ -131,13 +138,3 @@ class WebNavigationStateComparisonTest {
         )
     }
 }
-
-data class TestNavigationState(
-    override val originalUrl: String?,
-    override val currentUrl: String?,
-    override val title: String?,
-    override val stepsToPreviousPage: Int,
-    override val canGoBack: Boolean,
-    override val canGoForward: Boolean,
-    override val hasNavigationHistory: Boolean
-) : WebNavigationState

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

@@ -244,7 +244,7 @@ class BrowserActivity : DuckDuckGoActivity(), CoroutineScope {
         Timber.i("Processing command: $command")
         when (command) {
             is Query -> currentTab?.submitQuery(command.query)
-            is Refresh -> currentTab?.refresh()
+            is Refresh -> currentTab?.onRefreshRequested()
             is Command.DisplayMessage -> applicationContext?.longToast(command.messageId)
             is Command.LaunchPlayStore -> launchPlayStore()
             is Command.ShowAppEnjoymentPrompt -> showAppEnjoymentPrompt(AppEnjoymentDialogFragment.create(command.promptCount, viewModel))

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

@@ -203,6 +203,11 @@ class BrowserTabFragment : Fragment(), FindListener, CoroutineScope {
 
     private var webView: WebView? = null
 
+    private val errorSnackbar: Snackbar by lazy {
+        Snackbar.make(browserLayout, R.string.crashedWebViewErrorMessage, Snackbar.LENGTH_INDEFINITE)
+            .setBehavior(NonDismissibleBehavior())
+    }
+
     private val findInPageTextWatcher = object : TextChangedWatcher() {
         override fun afterTextChanged(editable: Editable) {
             viewModel.userFindingInPage(findInPageInput.text.toString())
@@ -309,7 +314,7 @@ class BrowserTabFragment : Fragment(), FindListener, CoroutineScope {
         popupMenu.apply {
             onMenuItemClicked(view.forwardPopupMenuItem) { viewModel.onUserPressedForward() }
             onMenuItemClicked(view.backPopupMenuItem) { activity?.onBackPressed() }
-            onMenuItemClicked(view.refreshPopupMenuItem) { refresh() }
+            onMenuItemClicked(view.refreshPopupMenuItem) { viewModel.onRefreshRequested() }
             onMenuItemClicked(view.newTabPopupMenuItem) { viewModel.userRequestedOpeningNewTab() }
             onMenuItemClicked(view.bookmarksPopupMenuItem) { browserActivity?.launchBookmarks() }
             onMenuItemClicked(view.addBookmarksPopupMenuItem) { launch { viewModel.onBookmarkAddRequested() } }
@@ -374,6 +379,8 @@ class BrowserTabFragment : Fragment(), FindListener, CoroutineScope {
     }
 
     private fun showHome() {
+        errorSnackbar.dismiss()
+        newTabLayout.show()
         showKeyboardImmediately()
         appBarLayout.setExpanded(true)
         webView?.onPause()
@@ -383,6 +390,7 @@ class BrowserTabFragment : Fragment(), FindListener, CoroutineScope {
     }
 
     private fun showBrowser() {
+        newTabLayout.gone()
         webView?.show()
         webView?.onResume()
         omnibarScrolling.enableOmnibarScrolling(toolbarContainer)
@@ -398,13 +406,17 @@ class BrowserTabFragment : Fragment(), FindListener, CoroutineScope {
         webView?.loadUrl(url)
     }
 
+    fun onRefreshRequested() {
+        viewModel.onRefreshRequested()
+    }
+
     fun refresh() {
         webView?.reload()
     }
 
     private fun processCommand(it: Command?) {
         when (it) {
-            Command.Refresh -> refresh()
+            is Command.Refresh -> refresh()
             is Command.OpenInNewTab -> {
                 browserActivity?.openInNewTab(it.query)
             }
@@ -419,10 +431,10 @@ class BrowserTabFragment : Fragment(), FindListener, CoroutineScope {
             is Command.NavigateBack -> {
                 webView?.goBackOrForward(-it.steps)
             }
-            Command.NavigateForward -> {
+            is Command.NavigateForward -> {
                 webView?.goForward()
             }
-            Command.ResetHistory -> {
+            is Command.ResetHistory -> {
                 resetWebView()
             }
             is Command.DialNumber -> {
@@ -439,10 +451,10 @@ class BrowserTabFragment : Fragment(), FindListener, CoroutineScope {
                 val intent = Intent(Intent.ACTION_SENDTO, Uri.parse("smsto:${it.telephoneNumber}"))
                 openExternalDialog(intent)
             }
-            Command.ShowKeyboard -> {
+            is Command.ShowKeyboard -> {
                 showKeyboard()
             }
-            Command.HideKeyboard -> {
+            is Command.HideKeyboard -> {
                 hideKeyboard()
             }
             is Command.BrokenSiteFeedback -> {
@@ -458,7 +470,7 @@ class BrowserTabFragment : Fragment(), FindListener, CoroutineScope {
             }
             is Command.DownloadImage -> requestImageDownload(it.url)
             is Command.FindInPageCommand -> webView?.findAllAsync(it.searchTerm)
-            Command.DismissFindInPage -> webView?.findAllAsync(null)
+            is Command.DismissFindInPage -> webView?.findAllAsync(null)
             is Command.ShareLink -> launchSharePageChooser(it.url)
             is Command.CopyLink -> {
                 clipboardManager.primaryClip = ClipData.newPlainText(null, it.url)
@@ -481,6 +493,14 @@ class BrowserTabFragment : Fragment(), FindListener, CoroutineScope {
             is Command.SaveCredentials -> saveBasicAuthCredentials(it.request, it.credentials)
             is Command.GenerateWebViewPreviewImage -> generateWebViewPreviewImage()
             is Command.LaunchTabSwitcher -> launchTabSwitcher()
+            is Command.ShowErrorWithAction -> showErrorSnackbar(it)
+        }
+    }
+
+    private fun showErrorSnackbar(command: Command.ShowErrorWithAction) {
+        //Snackbar is global and it should appear only the foreground fragment
+        if (!errorSnackbar.view.isAttachedToWindow && isVisible) {
+            errorSnackbar.setAction(R.string.crashedWebViewErrorAction) { command.action() }.show()
         }
     }
 
@@ -1124,13 +1144,23 @@ class BrowserTabFragment : Fragment(), FindListener, CoroutineScope {
         }
 
         fun renderGlobalViewState(viewState: GlobalLayoutViewState) {
+            if (lastSeenGlobalViewState is GlobalLayoutViewState.Invalidated &&
+                viewState is GlobalLayoutViewState.Browser) {
+                throw IllegalStateException("Invalid state transition")
+            }
+
             renderIfChanged(viewState, lastSeenGlobalViewState) {
                 lastSeenGlobalViewState = viewState
 
-                if (viewState.isNewTabState) {
-                    browserLayout.hide()
-                } else {
-                    browserLayout.show()
+                when (viewState) {
+                    is GlobalLayoutViewState.Browser -> {
+                        if (viewState.isNewTabState) {
+                            browserLayout.hide()
+                        } else {
+                            browserLayout.show()
+                        }
+                    }
+                    is GlobalLayoutViewState.Invalidated -> destroyWebView()
                 }
             }
         }
@@ -1174,6 +1204,8 @@ class BrowserTabFragment : Fragment(), FindListener, CoroutineScope {
                 newTabPopupMenuItem.isEnabled = browserShowing
                 addBookmarksPopupMenuItem?.isEnabled = viewState.canAddBookmarks
                 sharePageMenuItem?.isEnabled = viewState.canSharePage
+                brokenSitePopupMenuItem?.isEnabled = viewState.canReportSite
+                requestDesktopSiteCheckMenuItem?.isEnabled = viewState.canChangeBrowsingMode
 
                 addToHome?.let {
                     it.visibility = if (viewState.addToHomeVisible) VISIBLE else GONE