RequestServer: Retrieve timing info from curl and pipe it to LibWeb

This timing info will be used to create a PerformanceResourceTiming
entry.

Libraries/LibRequests/ALPNHttpVersion.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2025, Luke Wilde <luke@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/FlyString.h>
+
+namespace Requests {
+
+// https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids
+enum class ALPNHttpVersion {
+    None,
+    Http1_0,
+    Http1_1,
+    Http2_TLS,
+    Http2_TCP,
+    Http3,
+};
+
+inline FlyString alpn_http_version_to_fly_string(ALPNHttpVersion version)
+{
+    switch (version) {
+    case ALPNHttpVersion::None:
+        return ""_fly_string;
+    case ALPNHttpVersion::Http1_0:
+        return "http/1.0"_fly_string;
+    case ALPNHttpVersion::Http1_1:
+        return "http/1.1"_fly_string;
+    case ALPNHttpVersion::Http2_TLS:
+        return "h2"_fly_string;
+    case ALPNHttpVersion::Http2_TCP:
+        return "h2c"_fly_string;
+    case ALPNHttpVersion::Http3:
+        return "h3"_fly_string;
+    default:
+        VERIFY_NOT_REACHED();
+    }
+}
+
+}

Libraries/LibRequests/Forward.h

@@ -11,5 +11,6 @@ namespace Requests {
 class Request;
 class RequestClient;
 class WebSocket;
+struct RequestTimingInfo;
 
 }

Libraries/LibRequests/Request.cpp

@@ -53,12 +53,13 @@ void Request::set_buffered_request_finished_callback(BufferedRequestFinished on_
         m_internal_buffered_data->reason_phrase = reason_phrase;
     };
 
-    on_finish = [this, on_buffered_request_finished = move(on_buffered_request_finished)](auto total_size, auto network_error) {
+    on_finish = [this, on_buffered_request_finished = move(on_buffered_request_finished)](auto total_size, auto& timing_info, auto network_error) {
         auto output_buffer = ByteBuffer::create_uninitialized(m_internal_buffered_data->payload_stream.used_buffer_size()).release_value_but_fixme_should_propagate_errors();
         m_internal_buffered_data->payload_stream.read_until_filled(output_buffer).release_value_but_fixme_should_propagate_errors();
 
         on_buffered_request_finished(
             total_size,
+            timing_info,
             network_error,
             m_internal_buffered_data->response_headers,
             m_internal_buffered_data->response_code,
@@ -83,10 +84,10 @@ void Request::set_unbuffered_request_callbacks(HeadersReceived on_headers_receiv
     set_up_internal_stream_data(move(on_data_received));
 }
 
-void Request::did_finish(Badge<RequestClient>, u64 total_size, Optional<NetworkError> const& network_error)
+void Request::did_finish(Badge<RequestClient>, u64 total_size, RequestTimingInfo const& timing_info, Optional<NetworkError> const& network_error)
 {
     if (on_finish)
-        on_finish(total_size, network_error);
+        on_finish(total_size, timing_info, network_error);
 }
 
 void Request::did_receive_headers(Badge<RequestClient>, HTTP::HeaderMap const& response_headers, Optional<u32> response_code, Optional<String> const& reason_phrase)
@@ -115,9 +116,10 @@ void Request::set_up_internal_stream_data(DataReceived on_data_available)
         m_internal_stream_data->read_stream = MUST(Core::File::adopt_fd(fd(), Core::File::OpenMode::Read));
 
     auto user_on_finish = move(on_finish);
-    on_finish = [this](auto total_size, auto network_error) {
+    on_finish = [this](auto total_size, auto const& timing_info, auto network_error) {
         m_internal_stream_data->total_size = total_size;
         m_internal_stream_data->network_error = network_error;
+        m_internal_stream_data->timing_info = timing_info;
         m_internal_stream_data->request_done = true;
         m_internal_stream_data->on_finish();
     };
@@ -125,7 +127,7 @@ void Request::set_up_internal_stream_data(DataReceived on_data_available)
     m_internal_stream_data->on_finish = [this, user_on_finish = move(user_on_finish)]() {
         if (!m_internal_stream_data->user_finish_called && (!m_internal_stream_data->read_stream || m_internal_stream_data->read_stream->is_eof())) {
             m_internal_stream_data->user_finish_called = true;
-            user_on_finish(m_internal_stream_data->total_size, m_internal_stream_data->network_error);
+            user_on_finish(m_internal_stream_data->total_size, m_internal_stream_data->timing_info, m_internal_stream_data->network_error);
         }
     };
 

Libraries/LibRequests/Request.h

@@ -15,6 +15,7 @@
 #include <LibCore/Notifier.h>
 #include <LibHTTP/HeaderMap.h>
 #include <LibRequests/NetworkErrorEnum.h>
+#include <LibRequests/RequestTimingInfo.h>
 
 namespace Requests {
 
@@ -36,7 +37,7 @@ public:
     int fd() const { return m_fd; }
     bool stop();
 
-    using BufferedRequestFinished = Function<void(u64 total_size, Optional<NetworkError> const& network_error, HTTP::HeaderMap const& response_headers, Optional<u32> response_code, Optional<String> reason_phrase, ReadonlyBytes payload)>;
+    using BufferedRequestFinished = Function<void(u64 total_size, RequestTimingInfo const& timing_info, Optional<NetworkError> const& network_error, HTTP::HeaderMap const& response_headers, Optional<u32> response_code, Optional<String> reason_phrase, ReadonlyBytes payload)>;
 
     // Configure the request such that the entirety of the response data is buffered. The callback receives that data and
     // the response headers all at once. Using this method is mutually exclusive with `set_unbuffered_data_received_callback`.
@@ -44,7 +45,7 @@ public:
 
     using HeadersReceived = Function<void(HTTP::HeaderMap const& response_headers, Optional<u32> response_code, Optional<String> const& reason_phrase)>;
     using DataReceived = Function<void(ReadonlyBytes data)>;
-    using RequestFinished = Function<void(u64 total_size, Optional<NetworkError> network_error)>;
+    using RequestFinished = Function<void(u64 total_size, RequestTimingInfo const& timing_info, Optional<NetworkError> network_error)>;
 
     // Configure the request such that the response data is provided unbuffered as it is received. Using this method is
     // mutually exclusive with `set_buffered_request_finished_callback`.
@@ -52,7 +53,7 @@ public:
 
     Function<CertificateAndKey()> on_certificate_requested;
 
-    void did_finish(Badge<RequestClient>, u64 total_size, Optional<NetworkError> const& network_error);
+    void did_finish(Badge<RequestClient>, u64 total_size, RequestTimingInfo const& timing_info, Optional<NetworkError> const& network_error);
     void did_receive_headers(Badge<RequestClient>, HTTP::HeaderMap const& response_headers, Optional<u32> response_code, Optional<String> const& reason_phrase);
     void did_request_certificates(Badge<RequestClient>);
 
@@ -94,6 +95,7 @@ private:
         u32 total_size { 0 };
         Optional<NetworkError> network_error;
         bool request_done { false };
+        RequestTimingInfo timing_info;
         Function<void()> on_finish {};
         bool user_finish_called { false };
     };

Libraries/LibRequests/RequestClient.cpp

@@ -69,11 +69,11 @@ bool RequestClient::set_certificate(Badge<Request>, Request& request, ByteString
     return IPCProxy::set_certificate(request.id(), move(certificate), move(key));
 }
 
-void RequestClient::request_finished(i32 request_id, u64 total_size, Optional<NetworkError> const& network_error)
+void RequestClient::request_finished(i32 request_id, u64 total_size, RequestTimingInfo const& timing_info, Optional<NetworkError> const& network_error)
 {
     RefPtr<Request> request;
     if ((request = m_requests.get(request_id).value_or(nullptr))) {
-        request->did_finish({}, total_size, network_error);
+        request->did_finish({}, total_size, timing_info, network_error);
     }
     m_requests.remove(request_id);
 }

Libraries/LibRequests/RequestClient.h

@@ -9,6 +9,7 @@
 #include <AK/HashMap.h>
 #include <LibHTTP/HeaderMap.h>
 #include <LibIPC/ConnectionToServer.h>
+#include <LibRequests/RequestTimingInfo.h>
 #include <LibRequests/WebSocket.h>
 #include <LibWebSocket/WebSocket.h>
 #include <RequestServer/RequestClientEndpoint.h>
@@ -42,7 +43,7 @@ private:
     virtual void die() override;
 
     virtual void request_started(i32, IPC::File const&) override;
-    virtual void request_finished(i32, u64, Optional<NetworkError> const&) override;
+    virtual void request_finished(i32, u64, RequestTimingInfo const&, Optional<NetworkError> const&) override;
     virtual void certificate_requested(i32) override;
     virtual void headers_became_available(i32, HTTP::HeaderMap const&, Optional<u32> const&, Optional<String> const&) override;
 

Libraries/LibRequests/RequestTimingInfo.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2025, Luke Wilde <luke@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/FlyString.h>
+#include <LibIPC/Decoder.h>
+#include <LibIPC/Encoder.h>
+#include <LibRequests/ALPNHttpVersion.h>
+
+namespace Requests {
+
+struct RequestTimingInfo {
+    long domain_lookup_start_microseconds { 0 };
+    long domain_lookup_end_microseconds { 0 };
+    long connect_start_microseconds { 0 };
+    long connect_end_microseconds { 0 };
+    long secure_connect_start_microseconds { 0 };
+    long request_start_microseconds { 0 };
+    long response_start_microseconds { 0 };
+    long response_end_microseconds { 0 };
+    long encoded_body_size { 0 };
+    ALPNHttpVersion http_version_alpn_identifier { ALPNHttpVersion::None };
+};
+
+}
+
+namespace IPC {
+
+template<>
+inline ErrorOr<void> encode(Encoder& encoder, Requests::RequestTimingInfo const& timing_info)
+{
+    TRY(encoder.encode(timing_info.domain_lookup_start_microseconds));
+    TRY(encoder.encode(timing_info.domain_lookup_end_microseconds));
+    TRY(encoder.encode(timing_info.connect_start_microseconds));
+    TRY(encoder.encode(timing_info.connect_end_microseconds));
+    TRY(encoder.encode(timing_info.secure_connect_start_microseconds));
+    TRY(encoder.encode(timing_info.request_start_microseconds));
+    TRY(encoder.encode(timing_info.response_start_microseconds));
+    TRY(encoder.encode(timing_info.response_end_microseconds));
+    TRY(encoder.encode(timing_info.encoded_body_size));
+    TRY(encoder.encode(timing_info.http_version_alpn_identifier));
+    return {};
+}
+
+template<>
+inline ErrorOr<Requests::RequestTimingInfo> decode(Decoder& decoder)
+{
+    auto domain_lookup_start_microseconds = TRY(decoder.decode<long>());
+    auto domain_lookup_end_microseconds = TRY(decoder.decode<long>());
+    auto connect_start_microseconds = TRY(decoder.decode<long>());
+    auto connect_end_microseconds = TRY(decoder.decode<long>());
+    auto secure_connect_start_microseconds = TRY(decoder.decode<long>());
+    auto request_start_microseconds = TRY(decoder.decode<long>());
+    auto response_start_microseconds = TRY(decoder.decode<long>());
+    auto response_end_microseconds = TRY(decoder.decode<long>());
+    auto encoded_body_size = TRY(decoder.decode<long>());
+    auto http_version_alpn_identifier = TRY(decoder.decode<Requests::ALPNHttpVersion>());
+
+    return Requests::RequestTimingInfo {
+        .domain_lookup_start_microseconds = domain_lookup_start_microseconds,
+        .domain_lookup_end_microseconds = domain_lookup_end_microseconds,
+        .connect_start_microseconds = connect_start_microseconds,
+        .connect_end_microseconds = connect_end_microseconds,
+        .secure_connect_start_microseconds = secure_connect_start_microseconds,
+        .request_start_microseconds = request_start_microseconds,
+        .response_start_microseconds = response_start_microseconds,
+        .response_end_microseconds = response_end_microseconds,
+        .encoded_body_size = encoded_body_size,
+        .http_version_alpn_identifier = http_version_alpn_identifier,
+    };
+}
+
+}