Add webflow for importing bookmarks from Google (#6707)

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

### Description
Adds the core webflow to support a guided bookmark import based on
Google Takeout.
- This PR is only about the flow itself
- does not contain the final UI that will come before, during and after
the import flow (future PR to add this)
- does not contain timeouts / error handling if automation doesn't
complete
- does not make it available yet to production code, accessible through
`Autofill Dev Settings` screen for `internal` builds to test
- ℹ️ don't interact with the WebView while the automation is running; in
a later PR it won't be possible to interact with it during this flow

<img width="50%" alt="Screenshot 2025-09-24 at 16 02 57"
src="https://github.com/user-attachments/assets/72f333e0-5b02-4297-9315-fd92890bd330"
/>

### Steps to test this PR

#### First time import
- [x] Fresh install `internal` build type from this branch
- [x] Open `Settings->Autofill Dev Settings` 
- [x] Tap on `Launch Bookmarks import flow`
- [x] You won't be signed in yet, so sign in to your Google account when
prompted
- [x] After signing in, verify that automation takes care of the rest
and you eventually leave the web flow and see the success snackbar.
- [x] Tap on `View Bookmarks` and verify they imported under a `Imported
from Chrome` folder

#### Subsequent import (already signed in)
- [x] Tap on `Launch Bookmarks import flow` again. This time, you're
already signed so verify it jumps straight into the automation (and that
it succeeds)
- [x] Verify in `View Bookmarks` that there is only one `Imported From
Chrome` folder (bookmarks will be duplicated within that folder (it's
known we're matching existing bookmark importer behaviour within that
folder, including not further de-duplicating so if you import _n_ times
you'll see _n_ sets of copies of bookmarks in that one folder)

#### Check autofill works
- [x] Manually add your Google credentials to our password manager
- [x] Tap on `Google Account Logout` (from the `import passwords`
section) to logout of Google
- [x] Tap on `Launch Bookmarks import flow` again.
- [x] Verify you are prompted to autofill; accept
- [x] Verify the rest of the flow is automated and you don't have to
manually enter your password again

---------

Co-authored-by: Craig Russell <[email protected]>

Author: CDRussell

autofill/autofill-impl/build.gradle

@@ -48,6 +48,7 @@ dependencies {
     implementation project(path: ':settings-api') // temporary until we release new settings
     implementation project(':library-loader-api')
     implementation project(':saved-sites-api')
+    implementation project(':cookies-api')
 
     anvil project(path: ':anvil-compiler')
     implementation project(path: ':anvil-annotations')

autofill/autofill-impl/src/main/AndroidManifest.xml

@@ -21,6 +21,10 @@
             android:name=".importing.gpm.webflow.ImportGooglePasswordsWebFlowActivity"
             android:configChanges="keyboardHidden|orientation|screenSize|smallestScreenSize|screenLayout|navigation|keyboard"
             android:exported="false" />
+        <activity
+            android:name=".importing.takeout.webflow.ImportGoogleBookmarksWebFlowActivity"
+            android:configChanges="keyboardHidden|orientation|screenSize|smallestScreenSize|screenLayout|navigation|keyboard"
+            android:exported="false" />
         <activity
             android:name=".ui.credential.management.AutofillManagementActivity"
             android:configChanges="orientation|screenSize"

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/importing/gpm/webflow/PasswordImporterCssScriptLoader.kt renamed to autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/importing/gpm/webflow/GoogleImporterScriptLoader.kt

@@ -17,28 +17,40 @@
 package com.duckduckgo.autofill.impl.importing.gpm.webflow
 
 import com.duckduckgo.autofill.impl.importing.gpm.feature.AutofillImportPasswordConfigStore
+import com.duckduckgo.autofill.impl.importing.takeout.store.BookmarkImportConfigStore
 import com.duckduckgo.common.utils.DispatcherProvider
 import com.duckduckgo.di.scopes.FragmentScope
 import com.squareup.anvil.annotations.ContributesBinding
 import kotlinx.coroutines.withContext
 import java.io.BufferedReader
 import javax.inject.Inject
 
-interface PasswordImporterScriptLoader {
-    suspend fun getScript(): String
+interface GoogleImporterScriptLoader {
+    suspend fun getScriptForPasswordImport(): String
+
+    suspend fun getScriptForBookmarkImport(): String
 }
 
 @ContributesBinding(FragmentScope::class)
-class PasswordImporterCssScriptLoader @Inject constructor(
+class GoogleImporterScriptLoaderImpl @Inject constructor(
     private val dispatchers: DispatcherProvider,
-    private val configStore: AutofillImportPasswordConfigStore,
-) : PasswordImporterScriptLoader {
+    private val passwordConfigStore: AutofillImportPasswordConfigStore,
+    private val bookmarkConfigStore: BookmarkImportConfigStore,
+) : GoogleImporterScriptLoader {
     private lateinit var contentScopeJS: String
 
-    override suspend fun getScript(): String =
+    override suspend fun getScriptForPasswordImport(): String =
+        withContext(dispatchers.io()) {
+            getContentScopeJS()
+                .replace(CONTENT_SCOPE_PLACEHOLDER, getContentScopeScriptJson(loadSettingsJsonPassword()))
+                .replace(USER_UNPROTECTED_DOMAINS_PLACEHOLDER, getUnprotectedDomainsJson())
+                .replace(USER_PREFERENCES_PLACEHOLDER, getUserPreferencesJson())
+        }
+
+    override suspend fun getScriptForBookmarkImport(): String =
         withContext(dispatchers.io()) {
             getContentScopeJS()
-                .replace(CONTENT_SCOPE_PLACEHOLDER, getContentScopeJson(loadSettingsJson()))
+                .replace(CONTENT_SCOPE_PLACEHOLDER, getContentScopeScriptJson(loadSettingsJsonBookmark()))
                 .replace(USER_UNPROTECTED_DOMAINS_PLACEHOLDER, getUnprotectedDomainsJson())
                 .replace(USER_PREFERENCES_PLACEHOLDER, getUserPreferencesJson())
         }
@@ -47,7 +59,7 @@ class PasswordImporterCssScriptLoader @Inject constructor(
      * This enables the password import hints feature in C-S-S.
      * These settings are for enabling it; the check for whether it should be enabled or not is done elsewhere.
      */
-    private fun getContentScopeJson(settingsJson: String): String =
+    private fun getContentScopeScriptJson(settingsJson: String): String =
         """{
             "features":{
                 "autofillImport" : {
@@ -61,7 +73,9 @@ class PasswordImporterCssScriptLoader @Inject constructor(
 
         """.trimMargin()
 
-    private suspend fun loadSettingsJson(): String = configStore.getConfig().javascriptConfigGooglePasswords
+    private suspend fun loadSettingsJsonPassword(): String = passwordConfigStore.getConfig().javascriptConfigGooglePasswords
+
+    private suspend fun loadSettingsJsonBookmark(): String = bookmarkConfigStore.getConfig().javascriptConfigGoogleTakeout
 
     private fun getUserPreferencesJson(): String =
         """

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/importing/gpm/webflow/ImportGooglePasswordsWebFlowFragment.kt

@@ -33,7 +33,6 @@ import androidx.lifecycle.flowWithLifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.webkit.WebViewCompat
 import com.duckduckgo.anvil.annotations.InjectWith
-import com.duckduckgo.autofill.api.AutofillCapabilityChecker
 import com.duckduckgo.autofill.api.AutofillFragmentResultsPlugin
 import com.duckduckgo.autofill.api.BrowserAutofill
 import com.duckduckgo.autofill.api.CredentialAutofillDialogFactory
@@ -98,9 +97,6 @@ class ImportGooglePasswordsWebFlowFragment :
     @Inject
     lateinit var viewModelFactory: FragmentViewModelFactory
 
-    @Inject
-    lateinit var autofillCapabilityChecker: AutofillCapabilityChecker
-
     @Inject
     lateinit var credentialAutofillDialogFactory: CredentialAutofillDialogFactory
 
@@ -114,7 +110,7 @@ class ImportGooglePasswordsWebFlowFragment :
     lateinit var passwordBlobConsumer: GooglePasswordBlobConsumer
 
     @Inject
-    lateinit var passwordImporterScriptLoader: PasswordImporterScriptLoader
+    lateinit var googleImporterScriptLoader: GoogleImporterScriptLoader
 
     @Inject
     lateinit var browserAutofillConfigurator: InternalBrowserAutofillConfigurator
@@ -343,7 +339,7 @@ class ImportGooglePasswordsWebFlowFragment :
     @SuppressLint("RequiresFeature", "AddDocumentStartJavaScriptUsage")
     private suspend fun configurePasswordImportJavascript(webView: WebView) {
         if (importPasswordConfig.getConfig().canInjectJavascript) {
-            val script = passwordImporterScriptLoader.getScript()
+            val script = googleImporterScriptLoader.getScriptForPasswordImport()
             WebViewCompat.addDocumentStartJavaScript(webView, script, setOf("*"))
         }
     }

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/importing/takeout/processor/BookmarkImportProcessor.kt

@@ -0,0 +1,138 @@
+/*
+ * 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.autofill.impl.importing.takeout.processor
+
+import android.net.Uri
+import com.duckduckgo.autofill.impl.importing.takeout.processor.BookmarkImportProcessor.*
+import com.duckduckgo.autofill.impl.importing.takeout.processor.BookmarkImportProcessor.ImportResult.Error
+import com.duckduckgo.autofill.impl.importing.takeout.processor.BookmarkImportProcessor.ImportResult.Error.ParseError
+import com.duckduckgo.autofill.impl.importing.takeout.zip.TakeoutBookmarkExtractor
+import com.duckduckgo.autofill.impl.importing.takeout.zip.TakeoutBookmarkExtractor.ExtractionResult
+import com.duckduckgo.autofill.impl.importing.takeout.zip.TakeoutZipDownloader
+import com.duckduckgo.common.utils.DispatcherProvider
+import com.duckduckgo.di.scopes.AppScope
+import com.duckduckgo.savedsites.api.service.ImportSavedSitesResult
+import com.duckduckgo.savedsites.api.service.SavedSitesImporter.ImportFolder
+import com.squareup.anvil.annotations.ContributesBinding
+import kotlinx.coroutines.withContext
+import logcat.LogPriority.WARN
+import logcat.asLog
+import logcat.logcat
+import java.io.File
+import javax.inject.Inject
+
+interface BookmarkImportProcessor {
+    sealed class ImportResult {
+        data class Success(
+            val importedCount: Int,
+        ) : ImportResult()
+
+        sealed class Error : ImportResult() {
+            data object DownloadError : Error()
+
+            data object ParseError : Error()
+
+            data object ImportError : Error()
+        }
+    }
+
+    suspend fun downloadAndImportFromTakeoutZipUrl(
+        url: String,
+        userAgent: String,
+        folderName: String,
+    ): ImportResult
+}
+
+@ContributesBinding(AppScope::class)
+class TakeoutBookmarkImportProcessor @Inject constructor(
+    private val dispatchers: DispatcherProvider,
+    private val takeoutZipDownloader: TakeoutZipDownloader,
+    private val bookmarkExtractor: TakeoutBookmarkExtractor,
+    private val takeoutBookmarkImporter: TakeoutBookmarkImporter,
+) : BookmarkImportProcessor {
+    override suspend fun downloadAndImportFromTakeoutZipUrl(
+        url: String,
+        userAgent: String,
+        folderName: String,
+    ): ImportResult =
+        withContext(dispatchers.io()) {
+            runCatching {
+                val zipUri = takeoutZipDownloader.downloadZip(url, userAgent)
+                processBookmarkZip(zipUri, folderName)
+            }.getOrElse { e ->
+                logcat(WARN) { "Bookmark zip download failed: ${e.asLog()}" }
+                Error.DownloadError
+            }
+        }
+
+    private suspend fun processBookmarkZip(
+        zipUri: Uri,
+        folderName: String,
+    ): ImportResult =
+        runCatching {
+            val extractionResult = bookmarkExtractor.extractBookmarksFromFile(zipUri)
+            handleExtractionResult(extractionResult, folderName)
+        }.getOrElse { e ->
+            logcat(WARN) { "Error processing bookmark zip: ${e.asLog()}" }
+            ParseError
+        }.also {
+            cleanupZipFile(zipUri)
+        }
+
+    private suspend fun handleExtractionResult(
+        extractionResult: ExtractionResult,
+        folderName: String,
+    ): ImportResult =
+        when (extractionResult) {
+            is ExtractionResult.Success -> {
+                val importResult =
+                    takeoutBookmarkImporter.importBookmarks(
+                        extractionResult.tempFileUri,
+                        ImportFolder.Folder(folderName),
+                    )
+                handleImportResult(importResult)
+            }
+
+            is ExtractionResult.Error -> {
+                logcat(WARN) { "Error extracting bookmarks from zip" }
+                ParseError
+            }
+        }
+
+    private fun handleImportResult(importResult: ImportSavedSitesResult): ImportResult =
+        when (importResult) {
+            is ImportSavedSitesResult.Success -> {
+                val importedCount = importResult.savedSites.size
+                logcat { "Successfully imported $importedCount bookmarks" }
+                ImportResult.Success(importedCount)
+            }
+
+            is ImportSavedSitesResult.Error -> {
+                logcat(WARN) { "Error importing bookmarks: ${importResult.exception.message}" }
+                Error.ImportError
+            }
+        }
+
+    private fun cleanupZipFile(zipUri: Uri) {
+        runCatching {
+            val zipFile = File(zipUri.path ?: return)
+            if (zipFile.exists() && zipFile.delete()) {
+                logcat { "Cleaned up downloaded zip file: ${zipFile.absolutePath}" }
+            }
+        }.onFailure { logcat(WARN) { "Failed to cleanup downloaded zip file: ${it.asLog()}" } }
+    }
+}

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/importing/takeout/processor/TakeoutBookmarkImporter.kt

@@ -23,50 +23,50 @@ import com.duckduckgo.savedsites.api.service.ImportSavedSitesResult
 import com.duckduckgo.savedsites.api.service.SavedSitesImporter
 import com.duckduckgo.savedsites.api.service.SavedSitesImporter.ImportFolder
 import com.squareup.anvil.annotations.ContributesBinding
+import kotlinx.coroutines.withContext
 import java.io.File
 import javax.inject.Inject
-import kotlinx.coroutines.withContext
 
 /**
  * Interface for importing bookmarks with flexible destination handling.
  * Supports both root-level imports and folder-based imports while preserving structure.
  */
 interface TakeoutBookmarkImporter {
-
     /**
-     * Imports bookmarks from HTML content to the specified destination.
-     * @param htmlContent The HTML bookmark content to import (in Netscape format)
+     * Imports bookmarks from a temporary HTML file to the specified destination. The file will be deleted after import.
+     * @param tempFileUri URI of the temporary HTML file containing bookmark content (in Netscape format)
      * @param destination Where to import the bookmarks (Root or named Folder within bookmarks root)
      * @return ImportSavedSitesResult indicating success with imported items or error
      */
-    suspend fun importBookmarks(htmlContent: String, destination: ImportFolder): ImportSavedSitesResult
+    suspend fun importBookmarks(
+        tempFileUri: Uri,
+        destination: ImportFolder,
+    ): ImportSavedSitesResult
 }
 
 @ContributesBinding(AppScope::class)
 class RealTakeoutBookmarkImporter @Inject constructor(
     private val savedSitesImporter: SavedSitesImporter,
     private val dispatchers: DispatcherProvider,
 ) : TakeoutBookmarkImporter {
-
-    override suspend fun importBookmarks(htmlContent: String, destination: ImportFolder): ImportSavedSitesResult {
-        return withContext(dispatchers.io()) {
-            import(htmlContent = htmlContent, destination = destination)
-        }
-    }
-
-    private suspend fun import(htmlContent: String, destination: ImportFolder = ImportFolder.Root): ImportSavedSitesResult {
-        return try {
-            // saved sites importer needs a file uri, so we create a temp file here
-            val tempFile = File.createTempFile("bookmark_import_", ".html")
+    override suspend fun importBookmarks(
+        tempFileUri: Uri,
+        destination: ImportFolder,
+    ): ImportSavedSitesResult =
+        withContext(dispatchers.io()) {
             try {
-                tempFile.writeText(htmlContent)
-                return savedSitesImporter.import(Uri.fromFile(tempFile), destination)
+                savedSitesImporter.import(tempFileUri, destination)
+            } catch (exception: Exception) {
+                ImportSavedSitesResult.Error(exception)
             } finally {
-                // delete the temp file after import
-                tempFile.takeIf { it.exists() }?.delete()
+                cleanupTempFile(tempFileUri)
             }
-        } catch (exception: Exception) {
-            ImportSavedSitesResult.Error(exception)
+        }
+
+    private fun cleanupTempFile(tempFileUri: Uri) {
+        runCatching {
+            val filePath = tempFileUri.path ?: return
+            File(filePath).delete()
         }
     }
 }