LibWebView: Suggest about: pages in the omnibox

Offer case-insensitive prefix matches for known about pages and support
inline completion of those URLs. Keep about queries local instead of
sending them to a remote autocomplete provider.

Author: AtkinsSJ

Libraries/LibWebView/Autocomplete.cpp

@@ -24,10 +24,12 @@
 #include <LibWebView/HistoryDebug.h>
 #include <LibWebView/HistoryStore.h>
 #include <LibWebView/URL.h>
+#include <LibWebView/WebUI.h>
 
 namespace WebView {
 
 static constexpr auto file_url_prefix = "file://"sv;
+static constexpr auto about_url_prefix = "about:"sv;
 
 static constexpr auto builtin_autocomplete_engines = to_array<AutocompleteEngine>({
     { "DuckDuckGo"sv, "https://duckduckgo.com/ac/?q={}"sv },
@@ -150,6 +152,37 @@ Vector<String> filter_remote_autocomplete_suggestions(StringView input, Vector<S
     return suggestions;
 }
 
+Vector<AutocompleteSuggestion> web_ui_autocomplete_suggestions(StringView input)
+{
+    if (!input.starts_with(about_url_prefix, CaseSensitivity::CaseInsensitive))
+        return {};
+
+    Vector<AutocompleteSuggestion> suggestions;
+    suggestions.ensure_capacity(WebUI::pages().size());
+
+    for (auto const& page : WebUI::pages()) {
+        auto url = MUST(String::formatted("about:{}", page.host));
+        if (!url.bytes_as_string_view().starts_with(input, CaseSensitivity::CaseInsensitive))
+            continue;
+
+        suggestions.unchecked_append({
+            .source = AutocompleteSuggestionSource::WebUI,
+            .text = move(url),
+            .title = MUST(String::from_utf8(page.title)),
+            .subtitle = {},
+            .favicon_base64_png = {},
+            .highlight_input = {},
+            .match_class = AutocompleteMatchClass::URLPrefix,
+            .relevance = 1100,
+            .is_verbatim = false,
+            .can_be_automatically_selected = true,
+            .can_be_inline_completed = true,
+        });
+    }
+
+    return suggestions;
+}
+
 [[maybe_unused]] static ByteString log_autocomplete_suggestions(Vector<AutocompleteSuggestion> const& suggestions)
 {
     Vector<ByteString> values;
@@ -275,6 +308,13 @@ void Autocomplete::query_autocomplete_engine(AutocompleteQueryID query_id, Strin
         return;
     }
 
+    if (m_trimmed_query.bytes_as_string_view().starts_with(about_url_prefix, CaseSensitivity::CaseInsensitive)) {
+        m_remote_suggestions.clear();
+        m_remote_query_complete = true;
+        dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Skipping remote autocomplete for about URL query '{}'", m_trimmed_query);
+        return;
+    }
+
     auto engine = Application::settings().autocomplete_engine();
     if (!engine.has_value()) {
         m_remote_suggestions.clear();
@@ -362,13 +402,15 @@ void Autocomplete::deliver_current_result()
     if (!m_query_id.has_value())
         return;
 
-    auto verbatim_suggestion = literal_url_suggestion(m_query);
-    if (!verbatim_suggestion.has_value())
+    auto web_ui_suggestions = web_ui_autocomplete_suggestions(m_trimmed_query);
+    auto verbatim_suggestion = web_ui_suggestions.is_empty() ? literal_url_suggestion(m_query) : Optional<AutocompleteSuggestion> {};
+    if (web_ui_suggestions.is_empty() && !verbatim_suggestion.has_value())
         verbatim_suggestion = search_for_query_suggestion(m_query);
+    web_ui_suggestions.extend(m_local_suggestions);
     auto merged_suggestions = mux_autocomplete_suggestions(
         m_trimmed_query,
         move(verbatim_suggestion),
-        m_local_suggestions,
+        move(web_ui_suggestions),
         make_remote_suggestions(m_remote_suggestions),
         m_max_suggestions);
     for (auto& suggestion : merged_suggestions)

Libraries/LibWebView/Autocomplete.h

@@ -38,6 +38,7 @@ static constexpr auto default_autocomplete_suggestion_limit = 8uz;
 
 enum class AutocompleteSuggestionSource {
     LiteralURL,
+    WebUI,
     History,
     Bookmark,
     Adaptive,
@@ -91,6 +92,7 @@ WEBVIEW_API Optional<AutocompleteEngine const&> find_autocomplete_engine_by_name
 WEBVIEW_API String autocomplete_suggestion_display_text(AutocompleteSuggestion const&);
 WEBVIEW_API Vector<AutocompleteMatchRange> autocomplete_match_ranges(StringView input, StringView text);
 WEBVIEW_API Vector<String> filter_remote_autocomplete_suggestions(StringView input, Vector<String> suggestions);
+WEBVIEW_API Vector<AutocompleteSuggestion> web_ui_autocomplete_suggestions(StringView input);
 WEBVIEW_API bool autocomplete_urls_match(StringView left, StringView right);
 WEBVIEW_API bool autocomplete_url_can_complete(StringView query, StringView suggestion);
 

Tests/LibWebView/TestAutocomplete.cpp

@@ -217,6 +217,26 @@ ErrorOr<int> ladybird_main(Main::Arguments arguments)
         Core::EventLoop::current().spin_until([&]() { return whitespace_query_completed; });
     }
 
+    auto about_query_completed = false;
+    {
+        WebView::Autocomplete autocomplete { WebView::IsPrivate::No };
+        autocomplete.on_autocomplete_query_complete = [&](auto, auto const& suggestions, WebView::AutocompleteResultKind kind) {
+            if (kind != WebView::AutocompleteResultKind::Final)
+                return;
+            VERIFY(!suggestions.contains([](auto const& suggestion) {
+                return suggestion.source == WebView::AutocompleteSuggestionSource::Search;
+            }));
+            VERIFY(suggestions.contains([](auto const& suggestion) {
+                return suggestion.source == WebView::AutocompleteSuggestionSource::WebUI
+                    && suggestion.text == "about:settings"sv;
+            }));
+            autocomplete.cancel_pending_query();
+            about_query_completed = true;
+        };
+        autocomplete.query_autocomplete_engine(100, "about:set"_string);
+        Core::EventLoop::current().spin_until([&]() { return about_query_completed; });
+    }
+
     // A closed loopback port makes the request fail fast and deterministically, with no real network.
     // Its on_finish synchronously delivers the final result. A data: URL cannot be used because the request
     // server's DNS path requires a host.

Tests/LibWebView/TestOmnibox.cpp

@@ -6,6 +6,7 @@
 
 #include <LibTest/TestCase.h>
 #include <LibWebView/Omnibox.h>
+#include <LibWebView/WebUI.h>
 
 namespace {
 
@@ -23,7 +24,7 @@ AutocompleteSuggestion row(AutocompleteSuggestionSource source, StringView text)
         .favicon_base64_png = {},
         .highlight_input = {},
         .can_be_automatically_selected = true,
-        .can_be_inline_completed = source == AutocompleteSuggestionSource::History,
+        .can_be_inline_completed = source == AutocompleteSuggestionSource::History || source == AutocompleteSuggestionSource::WebUI,
     };
 }
 
@@ -64,6 +65,11 @@ AutocompleteSuggestion literal_row(StringView url)
     return row(AutocompleteSuggestionSource::LiteralURL, url);
 }
 
+AutocompleteSuggestion web_ui_row(StringView url)
+{
+    return row(AutocompleteSuggestionSource::WebUI, url);
+}
+
 class ScriptedProvider final : public WebView::OmniboxSuggestionProvider {
 public:
     virtual void query(WebView::AutocompleteQueryID query_id, String query, size_t) override
@@ -188,6 +194,46 @@ struct Harness {
 
 }
 
+TEST_CASE(all_web_ui_pages_are_suggested)
+{
+    static constexpr Array expected_urls {
+        "about:about"sv,
+        "about:bookmarks"sv,
+        "about:downloads"sv,
+        "about:history"sv,
+        "about:newtab"sv,
+        "about:processes"sv,
+        "about:settings"sv,
+        "about:version"sv,
+    };
+
+    auto suggestions = WebView::web_ui_autocomplete_suggestions("about:"sv);
+
+    EXPECT_EQ(WebView::WebUI::pages().size(), expected_urls.size());
+    EXPECT_EQ(suggestions.size(), expected_urls.size());
+    for (size_t index = 0; index < expected_urls.size(); ++index) {
+        EXPECT_EQ(suggestions[index].source, WebView::AutocompleteSuggestionSource::WebUI);
+        EXPECT_EQ(suggestions[index].text, expected_urls[index]);
+    }
+}
+
+TEST_CASE(web_ui_pages_are_matched_by_case_insensitive_url_prefix)
+{
+    auto suggestions = WebView::web_ui_autocomplete_suggestions("ABOUT:SET"sv);
+
+    EXPECT_EQ(suggestions.size(), 1u);
+    EXPECT_EQ(suggestions[0].text, "about:settings"sv);
+    EXPECT_EQ(suggestions[0].title, "Settings"sv);
+    EXPECT(suggestions[0].can_be_automatically_selected);
+    EXPECT(suggestions[0].can_be_inline_completed);
+}
+
+TEST_CASE(web_ui_pages_are_not_suggested_for_unrelated_input)
+{
+    EXPECT(WebView::web_ui_autocomplete_suggestions("settings"sv).is_empty());
+    EXPECT(WebView::web_ui_autocomplete_suggestions("about:foo"sv).is_empty());
+}
+
 TEST_CASE(fast_typing_publishes_each_local_generation)
 {
     Harness harness;
@@ -609,6 +655,23 @@ TEST_CASE(a_literal_url_suggestion_never_completes)
     EXPECT_EQ(harness.commits.last(), "t.example/path"sv);
 }
 
+TEST_CASE(a_web_ui_suggestion_completes_and_commits_as_a_url)
+{
+    Harness harness;
+    harness.begin_editing();
+    harness.display_text = "about:set"_string;
+    harness.omnibox.text_edited(harness.display_text, true);
+
+    harness.provider->deliver({ web_ui_row("about:settings"sv) });
+    EXPECT_EQ(harness.display_text, "about:settings"sv);
+    EXPECT_EQ(harness.selection_start, 9u);
+    EXPECT_EQ(harness.omnibox.selected_suggestion(), 0u);
+
+    harness.omnibox.return_pressed();
+    EXPECT_EQ(harness.commits.last(), "about:settings"sv);
+    EXPECT_EQ(harness.provider->engagements.last().destination_kind, WebView::OmniboxDestinationKind::URL);
+}
+
 TEST_CASE(an_automatic_default_does_not_imply_inline_completion)
 {
     Harness harness;