LibWebView: Wire geolocation through WebContent

Connect WebContent geolocation requests to the browser-process provider
owned by Application. Responses are keyed by request ID and guarded by
the originating view, page, and client handle so late callbacks from
navigation or teardown are ignored.

Active native watches are stopped when WebContent cancels them, when a
permission-denied response terminates the watch, or when the owning view
is destroyed.

Author: gmta

Libraries/LibWeb/HTML/LocalTraversableNavigable.cpp

@@ -150,21 +150,15 @@ GC::Ref<LocalTraversableNavigable> LocalTraversableNavigable::create_a_fresh_top
     auto traversable = create_a_new_top_level_traversable(page, nullptr, {});
     page->set_top_level_traversable(traversable);
 
-    // AD-HOC: Set the default top-level emulated position data for the traversable, which points to Market St. SF.
-    // FIXME: We should not emulate by default, but ask the user what to do. E.g. disable Geolocation, set an emulated
-    //        position, or allow Ladybird to engage with the system's geolocation services. This is completely separate
-    //        from the permission model for "powerful features" such as Geolocation.
+    // AD-HOC: Set default emulated position data for the traversable. The UI process will override this with the
+    //         user's geolocation settings via IPC, but this ensures a safe default if the IPC hasn't arrived yet.
     auto& realm = traversable->active_document()->realm();
     auto emulated_position_coordinates = realm.create<Geolocation::GeolocationCoordinates>(
         realm,
         Geolocation::CoordinatesData {
             .accuracy = 100.0,
             .latitude = 37.7647658,
             .longitude = -122.4345892,
-            .altitude = 60.0,
-            .altitude_accuracy = 10.0,
-            .heading = 0.0,
-            .speed = 0.0,
         });
     traversable->set_emulated_position_data(emulated_position_coordinates);
 

Libraries/LibWebView/Application.cpp

@@ -2043,6 +2043,49 @@ void Application::toggle_bookmark_for_view(ViewImplementation& view)
         });
 }
 
+ErrorOr<NonnullRawPtr<Core::GeolocationProvider>> Application::ensure_geolocation_provider()
+{
+    if (!m_geolocation_provider)
+        m_geolocation_provider = TRY(Core::GeolocationProvider::create());
+
+    return NonnullRawPtr { *m_geolocation_provider };
+}
+
+static Core::GeolocationError geolocation_provider_unavailable_error(Error const& error)
+{
+    return {
+        .type = Core::GeolocationError::Type::PositionUnavailable,
+        .message = MUST(String::from_utf8(error.string_literal())),
+    };
+}
+
+void Application::request_geolocation_position(Core::GeolocationProvider::SuccessCallback on_success, Core::GeolocationProvider::ErrorCallback on_error)
+{
+    auto provider = ensure_geolocation_provider();
+    if (provider.is_error()) {
+        on_error(geolocation_provider_unavailable_error(provider.error()));
+        return;
+    }
+    provider.value()->request_current_position(move(on_success), move(on_error));
+}
+
+ErrorOr<Core::GeolocationProvider::WatchId, Core::GeolocationError> Application::start_watching_geolocation_position(Core::GeolocationProvider::SuccessCallback on_success, Core::GeolocationProvider::ErrorCallback on_error)
+{
+    auto provider = ensure_geolocation_provider();
+    if (provider.is_error())
+        return geolocation_provider_unavailable_error(provider.error());
+
+    return provider.value()->start_watching_position(move(on_success), move(on_error));
+}
+
+void Application::stop_watching_geolocation_position(Core::GeolocationProvider::WatchId watch_id)
+{
+    if (!m_geolocation_provider)
+        return;
+
+    m_geolocation_provider->stop_watching_position(watch_id);
+}
+
 void Application::create_bookmark_menu_items(Optional<MenuData> data)
 {
     auto const& [menu, items, target_folder_id] = data.ensure([&]() -> MenuData {

Libraries/LibWebView/Application.h

@@ -9,10 +9,12 @@
 #include <AK/ByteString.h>
 #include <AK/Function.h>
 #include <AK/LexicalPath.h>
+#include <AK/NonnullRawPtr.h>
 #include <AK/Optional.h>
 #include <LibCore/AnonymousBuffer.h>
 #include <LibCore/EventLoop.h>
 #include <LibCore/Forward.h>
+#include <LibCore/GeolocationProvider.h>
 #include <LibDatabase/Forward.h>
 #include <LibDevTools/DevToolsDelegate.h>
 #include <LibDevTools/Forward.h>
@@ -125,6 +127,10 @@ class WEBVIEW_API Application : public DevTools::DevToolsDelegate {
     void set_browser_process_transport_handler(Function<void(NonnullOwnPtr<IPC::Transport>)> handler);
 #endif
 
+    void request_geolocation_position(Core::GeolocationProvider::SuccessCallback on_success, Core::GeolocationProvider::ErrorCallback on_error);
+    ErrorOr<Core::GeolocationProvider::WatchId, Core::GeolocationError> start_watching_geolocation_position(Core::GeolocationProvider::SuccessCallback on_success, Core::GeolocationProvider::ErrorCallback on_error);
+    void stop_watching_geolocation_position(Core::GeolocationProvider::WatchId);
+
     ErrorOr<NonnullRefPtr<WebContentClient>> launch_web_content_process(ViewImplementation&);
     struct ChildFrameWebContentProcess {
         NonnullRefPtr<WebContentClient> client;
@@ -297,6 +303,7 @@ class WEBVIEW_API Application : public DevTools::DevToolsDelegate {
     ErrorOr<void> launch_image_decoder_server();
     ErrorOr<void> launch_devtools_server();
     ErrorOr<void> load_content_blocker_lists();
+    ErrorOr<NonnullRawPtr<Core::GeolocationProvider>> ensure_geolocation_provider();
 
     void initialize_actions();
     void update_vertical_tabs_action();
@@ -427,6 +434,7 @@ class WEBVIEW_API Application : public DevTools::DevToolsDelegate {
     OwnPtr<StorageJar> m_storage_jar;
     OwnPtr<PrivateBrowsingSession> m_private_browsing_session;
 
+    OwnPtr<Core::GeolocationProvider> m_geolocation_provider;
     OwnPtr<Core::TimeZoneWatcher> m_time_zone_watcher;
 
     Core::EventLoop* m_event_loop { nullptr };

Libraries/LibWebView/ViewImplementation.cpp

@@ -19,6 +19,7 @@
 #include <LibURL/Parser.h>
 #include <LibWeb/CSS/SystemColor.h>
 #include <LibWeb/Crypto/Crypto.h>
+#include <LibWeb/Geolocation/GeolocationPositionError.h>
 #include <LibWeb/Infra/Strings.h>
 #include <LibWeb/WebDriver/Error.h>
 #include <LibWebView/Application.h>
@@ -85,6 +86,10 @@ ViewImplementation::ViewImplementation(IsPrivate is_private)
 
 ViewImplementation::~ViewImplementation()
 {
+    for (auto const& watch : m_geolocation_watch_ids)
+        Application::the().stop_watching_geolocation_position(watch.value);
+    m_geolocation_watch_ids.clear();
+
     all_views().remove(m_view_id);
 
     if (m_client_state.client)
@@ -1475,6 +1480,88 @@ void ViewImplementation::initialize_client(CreateNewClient create_new_client)
     browsing_behavior_changed();
     autoplay_settings_changed();
     global_privacy_control_changed();
+    geolocation_settings_changed();
+
+    auto make_geolocation_success_handler = [this](u64 request_id) {
+        auto weak_this = make_weak_ptr();
+        auto request_page_id = page_id();
+        auto request_client_handle = m_client_state.client_handle;
+
+        return [weak_this, request_page_id, request_client_handle, request_id](Core::GeolocationCoordinates coords) {
+            auto* view = weak_this.ptr();
+            if (!view || !view->m_client_state.client || view->m_client_state.page_index != request_page_id || view->m_client_state.client_handle != request_client_handle)
+                return;
+
+            view->client().async_geolocation_position_response(request_page_id, request_id,
+                coords.latitude, coords.longitude, coords.accuracy,
+                coords.altitude, coords.altitude_accuracy,
+                coords.heading, coords.speed, {});
+        };
+    };
+
+    auto make_geolocation_error_handler = [this](u64 request_id, bool is_watch) {
+        using ErrorCode = Web::Geolocation::GeolocationPositionError::ErrorCode;
+
+        auto weak_this = make_weak_ptr();
+        auto request_page_id = page_id();
+        auto request_client_handle = m_client_state.client_handle;
+
+        return [weak_this, request_page_id, request_client_handle, request_id, is_watch](Core::GeolocationError error) {
+            auto* view = weak_this.ptr();
+            if (!view || !view->m_client_state.client || view->m_client_state.page_index != request_page_id || view->m_client_state.client_handle != request_client_handle)
+                return;
+
+            ErrorCode code;
+            switch (error.type) {
+            case Core::GeolocationError::Type::PermissionDenied:
+                code = ErrorCode::PermissionDenied;
+                break;
+            case Core::GeolocationError::Type::Timeout:
+                code = ErrorCode::Timeout;
+                break;
+            case Core::GeolocationError::Type::PositionUnavailable:
+                code = ErrorCode::PositionUnavailable;
+                break;
+            }
+
+            if (is_watch && code == ErrorCode::PermissionDenied) {
+                auto provider_watch_id = view->m_geolocation_watch_ids.take(request_id);
+                if (provider_watch_id.has_value())
+                    Application::the().stop_watching_geolocation_position(*provider_watch_id);
+            }
+
+            view->client().async_geolocation_position_response(request_page_id, request_id,
+                {}, {}, {}, {}, {}, {}, {},
+                to_underlying(code));
+        };
+    };
+
+    on_request_geolocation_position = [make_geolocation_success_handler, make_geolocation_error_handler](u64 request_id) {
+        Application::the().request_geolocation_position(
+            make_geolocation_success_handler(request_id),
+            make_geolocation_error_handler(request_id, false));
+    };
+
+    on_start_geolocation_position_watch = [this, make_geolocation_success_handler, make_geolocation_error_handler](u64 request_id) {
+        auto provider_watch_id = Application::the().start_watching_geolocation_position(
+            make_geolocation_success_handler(request_id),
+            make_geolocation_error_handler(request_id, true));
+
+        if (provider_watch_id.is_error()) {
+            make_geolocation_error_handler(request_id, true)(provider_watch_id.release_error());
+            return;
+        }
+
+        m_geolocation_watch_ids.set(request_id, provider_watch_id.release_value());
+    };
+
+    on_stop_geolocation_position_watch = [this](u64 request_id) {
+        auto provider_watch_id = m_geolocation_watch_ids.take(request_id);
+        if (!provider_watch_id.has_value())
+            return;
+
+        Application::the().stop_watching_geolocation_position(*provider_watch_id);
+    };
 
     // If DevTools is connected, notify the new WebContent process.
     if (m_devtools_connected)
@@ -2115,7 +2202,25 @@ void ViewImplementation::geolocation_settings_changed()
 {
     using ErrorCode = Web::Geolocation::GeolocationPositionError::ErrorCode;
 
+    auto stop_native_position_watches = [this](Optional<ErrorCode> error_code) {
+        auto geolocation_watch_ids = move(m_geolocation_watch_ids);
+        m_geolocation_watch_ids.clear();
+
+        for (auto const& watch : geolocation_watch_ids) {
+            Application::the().stop_watching_geolocation_position(watch.value);
+
+            if (error_code.has_value()) {
+                client().async_geolocation_position_response(page_id(), watch.key,
+                    {}, {}, {}, {}, {}, {}, {},
+                    to_underlying(*error_code));
+            } else {
+                client().async_cancel_geolocation_position_request(page_id(), watch.key);
+            }
+        }
+    };
+
     if (Application::web_content_options().is_test_mode == IsTestMode::Yes) {
+        stop_native_position_watches({});
         client().async_set_geolocation_emulated_position(page_id(), 37.7647658, -122.4345892, 100.0, 0.0, 0.0, 0.0, 0.0, {});
         return;
     }
@@ -2124,9 +2229,11 @@ void ViewImplementation::geolocation_settings_changed()
 
     switch (settings.geolocation_mode()) {
     case GeolocationMode::Disabled:
+        stop_native_position_watches(ErrorCode::PermissionDenied);
         client().async_set_geolocation_emulated_position(page_id(), {}, {}, {}, {}, {}, {}, {}, to_underlying(ErrorCode::PermissionDenied));
         break;
     case GeolocationMode::Emulated: {
+        stop_native_position_watches({});
         auto const& coords = settings.emulated_geolocation_coordinates();
         client().async_set_geolocation_emulated_position(page_id(), coords.latitude, coords.longitude, coords.accuracy, coords.altitude, coords.altitude_accuracy, coords.heading, coords.speed, {});
         break;

Libraries/LibWebView/ViewImplementation.h

@@ -9,6 +9,7 @@
 
 #include <AK/Forward.h>
 #include <AK/Function.h>
+#include <AK/HashMap.h>
 #include <AK/JsonArray.h>
 #include <AK/JsonObject.h>
 #include <AK/JsonValue.h>
@@ -18,8 +19,10 @@
 #include <AK/String.h>
 #include <AK/Types.h>
 #include <AK/Utf16String.h>
+#include <AK/Weakable.h>
 #include <LibCore/AnonymousBuffer.h>
 #include <LibCore/Forward.h>
+#include <LibCore/GeolocationProvider.h>
 #include <LibCore/Promise.h>
 #include <LibCore/SharedVersion.h>
 #include <LibDevTools/DevToolsDelegate.h>
@@ -63,7 +66,8 @@ namespace WebView {
 
 class WEBVIEW_API ViewImplementation
     : public SettingsObserver
-    , public BookmarkStoreObserver {
+    , public BookmarkStoreObserver
+    , public Weakable<ViewImplementation> {
     friend class WebContentClient;
 
 public:
@@ -365,6 +369,9 @@ class WEBVIEW_API ViewImplementation
     Function<void()> on_fullscreen_window;
     Function<void()> on_exit_fullscreen_window;
     Function<void(Color current_color)> on_request_color_picker;
+    Function<void(u64 request_id)> on_request_geolocation_position;
+    Function<void(u64 request_id)> on_start_geolocation_position_watch;
+    Function<void(u64 request_id)> on_stop_geolocation_position_watch;
     Function<void(Web::HTML::FileFilter const& accepted_file_types, Web::HTML::AllowMultipleFiles)> on_request_file_picker;
     Function<void(Gfx::IntPoint content_position, i32 minimum_width, Vector<Web::HTML::SelectItem> items)> on_request_select_dropdown;
     Function<void(Web::KeyEvent const&)> on_finish_handling_key_event;
@@ -477,6 +484,7 @@ class WEBVIEW_API ViewImplementation
     virtual void browsing_behavior_changed() override;
     virtual void autoplay_settings_changed() override;
     virtual void global_privacy_control_changed() override;
+    virtual void geolocation_settings_changed() override;
 
     virtual void bookmarks_changed() override;
     void update_bookmark_action();
@@ -618,6 +626,8 @@ class WEBVIEW_API ViewImplementation
 
     Web::ViewportIsFullscreen m_is_fullscreen { Web::ViewportIsFullscreen::No };
 
+    HashMap<u64, Core::GeolocationProvider::WatchId> m_geolocation_watch_ids;
+
     Core::AnonymousBuffer m_document_cookie_version_buffer;
     HashMap<String, Core::SharedVersionIndex> m_document_cookie_version_indices;
     DevTools::DevToolsDelegate::OnHostCookieChange m_on_host_cookie_change;

Libraries/LibWebView/WebContentClient.cpp

@@ -1707,6 +1707,30 @@ void WebContentClient::did_request_color_picker(u64 page_id, Color current_color
     }
 }
 
+void WebContentClient::did_request_geolocation_position(u64 page_id, u64 request_id)
+{
+    if (auto view = view_for_page_id(page_id); view.has_value()) {
+        if (view->on_request_geolocation_position)
+            view->on_request_geolocation_position(request_id);
+    }
+}
+
+void WebContentClient::did_start_geolocation_position_watch(u64 page_id, u64 request_id)
+{
+    if (auto view = view_for_page_id(page_id); view.has_value()) {
+        if (view->on_start_geolocation_position_watch)
+            view->on_start_geolocation_position_watch(request_id);
+    }
+}
+
+void WebContentClient::did_stop_geolocation_position_watch(u64 page_id, u64 request_id)
+{
+    if (auto view = view_for_page_id(page_id); view.has_value()) {
+        if (view->on_stop_geolocation_position_watch)
+            view->on_stop_geolocation_position_watch(request_id);
+    }
+}
+
 void WebContentClient::did_request_file_picker(u64 page_id, Web::HTML::FileFilter accepted_file_types, Web::HTML::AllowMultipleFiles allow_multiple_files)
 {
     if (auto view = view_for_page_id(page_id); view.has_value()) {

Libraries/LibWebView/WebContentClient.h

@@ -231,6 +231,9 @@ class WEBVIEW_API WebContentClient final
     virtual void did_request_exit_fullscreen(u64 page_id) override;
     virtual void did_request_file(u64 page_id, ByteString path, i32) override;
     virtual void did_request_color_picker(u64 page_id, Color current_color) override;
+    virtual void did_request_geolocation_position(u64 page_id, u64 request_id) override;
+    virtual void did_start_geolocation_position_watch(u64 page_id, u64 request_id) override;
+    virtual void did_stop_geolocation_position_watch(u64 page_id, u64 request_id) override;
     virtual void did_request_file_picker(u64 page_id, Web::HTML::FileFilter accepted_file_types, Web::HTML::AllowMultipleFiles) override;
     virtual void did_request_select_dropdown(u64 page_id, Gfx::IntPoint content_position, i32 minimum_width, Vector<Web::HTML::SelectItem> items) override;
     virtual void did_finish_handling_input_event(u64 page_id, Web::EventResult event_result) override;

Services/WebContent/ConnectionFromClient.cpp

@@ -2347,6 +2347,24 @@ void ConnectionFromClient::set_enable_global_privacy_control(u64, bool enable)
     Web::ResourceLoader::the().set_enable_global_privacy_control(enable);
 }
 
+void ConnectionFromClient::set_geolocation_emulated_position(u64 page_id, Optional<double> latitude, Optional<double> longitude, Optional<double> accuracy, Optional<double> altitude, Optional<double> altitude_accuracy, Optional<double> heading, Optional<double> speed, Optional<u16> error_code)
+{
+    if (auto page = this->page(page_id); page.has_value())
+        page->set_geolocation_emulated_position(latitude, longitude, accuracy, altitude, altitude_accuracy, heading, speed, error_code);
+}
+
+void ConnectionFromClient::cancel_geolocation_position_request(u64 page_id, u64 request_id)
+{
+    if (auto page = this->page(page_id); page.has_value())
+        page->cancel_geolocation_position_request(request_id);
+}
+
+void ConnectionFromClient::geolocation_position_response(u64 page_id, u64 request_id, Optional<double> latitude, Optional<double> longitude, Optional<double> accuracy, Optional<double> altitude, Optional<double> altitude_accuracy, Optional<double> heading, Optional<double> speed, Optional<u16> error_code)
+{
+    if (auto page = this->page(page_id); page.has_value())
+        page->geolocation_position_response(request_id, latitude, longitude, accuracy, altitude, altitude_accuracy, heading, speed, error_code);
+}
+
 void ConnectionFromClient::set_has_focus(u64 page_id, bool has_focus)
 {
     if (auto page = this->page(page_id); page.has_value())

Services/WebContent/ConnectionFromClient.h

@@ -163,6 +163,9 @@ class ConnectionFromClient final
     virtual void set_preferred_languages(u64 page_id, Vector<String>) override;
     virtual void set_browsing_behavior(u64 page_id, WebView::BrowsingBehavior) override;
     virtual void set_enable_global_privacy_control(u64 page_id, bool) override;
+    virtual void set_geolocation_emulated_position(u64 page_id, Optional<double> latitude, Optional<double> longitude, Optional<double> accuracy, Optional<double> altitude, Optional<double> altitude_accuracy, Optional<double> heading, Optional<double> speed, Optional<u16> error_code) override;
+    virtual void cancel_geolocation_position_request(u64 page_id, u64 request_id) override;
+    virtual void geolocation_position_response(u64 page_id, u64 request_id, Optional<double> latitude, Optional<double> longitude, Optional<double> accuracy, Optional<double> altitude, Optional<double> altitude_accuracy, Optional<double> heading, Optional<double> speed, Optional<u16> error_code) override;
     virtual void set_has_focus(u64 page_id, bool) override;
     virtual void set_is_scripting_enabled(u64 page_id, bool) override;
     virtual void set_zoom_level(u64 page_id, double zoom_level) override;