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,
+    };
+}
+
+}

Libraries/LibWeb/Fetch/Fetching/Fetching.cpp

@@ -12,6 +12,7 @@
 #include <AK/Debug.h>
 #include <AK/ScopeGuard.h>
 #include <LibJS/Runtime/Completion.h>
+#include <LibRequests/RequestTimingInfo.h>
 #include <LibWeb/Bindings/MainThreadVM.h>
 #include <LibWeb/Bindings/PrincipalHostDefined.h>
 #include <LibWeb/Cookie/Cookie.h>
@@ -2399,7 +2400,7 @@ WebIDL::ExceptionOr<GC::Ref<PendingResponse>> nonstandard_resource_loader_file_o
             }
         });
 
-        auto on_complete = GC::create_function(vm.heap(), [&vm, &realm, pending_response, stream](bool success, Optional<StringView> error_message) {
+        auto on_complete = GC::create_function(vm.heap(), [&vm, &realm, pending_response, stream](bool success, Requests::RequestTimingInfo const&, Optional<StringView> error_message) {
             HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
 
             // 16.1.1.2. Otherwise, if the bytes transmission for response’s message body is done normally and stream is readable,
@@ -2422,7 +2423,7 @@ WebIDL::ExceptionOr<GC::Ref<PendingResponse>> nonstandard_resource_loader_file_o
 
         ResourceLoader::the().load_unbuffered(load_request, on_headers_received, on_data_received, on_complete);
     } else {
-        auto on_load_success = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ReadonlyBytes data, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase) {
+        auto on_load_success = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ReadonlyBytes data, Requests::RequestTimingInfo const&, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase) {
             (void)request;
             dbgln_if(WEB_FETCH_DEBUG, "Fetch: ResourceLoader load for '{}' complete", request->url());
             if constexpr (WEB_FETCH_DEBUG)
@@ -2442,7 +2443,7 @@ WebIDL::ExceptionOr<GC::Ref<PendingResponse>> nonstandard_resource_loader_file_o
             pending_response->resolve(response);
         });
 
-        auto on_load_error = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ByteString const& error, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes data, HTTP::HeaderMap const& response_headers) {
+        auto on_load_error = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ByteString const& error, Requests::RequestTimingInfo const&, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes data, HTTP::HeaderMap const& response_headers) {
             (void)request;
             dbgln_if(WEB_FETCH_DEBUG, "Fetch: ResourceLoader load for '{}' failed: {} (status {})", request->url(), error, status_code.value_or(0));
             if constexpr (WEB_FETCH_DEBUG)

Libraries/LibWeb/Loader/ResourceLoader.cpp

@@ -110,10 +110,10 @@ RefPtr<Resource> ResourceLoader::load_resource(Resource::Type type, LoadRequest&
 
     load(
         request,
-        GC::create_function(m_heap, [resource](ReadonlyBytes data, HTTP::HeaderMap const& headers, Optional<u32> status_code, Optional<String> const&) {
+        GC::create_function(m_heap, [resource](ReadonlyBytes data, Requests::RequestTimingInfo const&, HTTP::HeaderMap const& headers, Optional<u32> status_code, Optional<String> const&) {
             resource->did_load({}, data, headers, status_code);
         }),
-        GC::create_function(m_heap, [resource](ByteString const& error, Optional<u32> status_code, Optional<String> const&, ReadonlyBytes data, HTTP::HeaderMap const& headers) {
+        GC::create_function(m_heap, [resource](ByteString const& error, Requests::RequestTimingInfo const&, Optional<u32> status_code, Optional<String> const&, ReadonlyBytes data, HTTP::HeaderMap const& headers) {
             resource->did_fail({}, error, data, headers, status_code);
         }));
 
@@ -240,23 +240,26 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
     request.start_timer();
 
     if (should_block_request(request)) {
-        error_callback->function()("Request was blocked", {}, {}, {}, {});
+        error_callback->function()("Request was blocked", {}, {}, {}, {}, {});
         return;
     }
 
     auto respond_directory_page = [](LoadRequest const& request, URL::URL const& url, GC::Root<SuccessCallback> success_callback, GC::Root<ErrorCallback> error_callback) {
+        // FIXME: Implement timing info for directory requests.
+        Requests::RequestTimingInfo fixme_implement_timing_info {};
+
         auto maybe_response = load_file_directory_page(url);
         if (maybe_response.is_error()) {
             log_failure(request, maybe_response.error());
             if (error_callback)
-                error_callback->function()(ByteString::formatted("{}", maybe_response.error()), 500u, {}, {}, {});
+                error_callback->function()(ByteString::formatted("{}", maybe_response.error()), fixme_implement_timing_info, 500u, {}, {}, {});
             return;
         }
 
         log_success(request);
         HTTP::HeaderMap response_headers;
         response_headers.set("Content-Type"sv, "text/html"sv);
-        success_callback->function()(maybe_response.release_value().bytes(), response_headers, {}, {});
+        success_callback->function()(maybe_response.release_value().bytes(), fixme_implement_timing_info, response_headers, {}, {});
     };
 
     if (url.scheme() == "about") {
@@ -266,9 +269,12 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
         HTTP::HeaderMap response_headers;
         response_headers.set("Content-Type", "text/html; charset=UTF-8");
 
+        // FIXME: Implement timing info for about requests.
+        Requests::RequestTimingInfo fixme_implement_timing_info {};
+
         // About version page
         if (url.path_segment_at_index(0) == "version") {
-            success_callback->function()(MUST(load_about_version_page()).bytes(), response_headers, {}, {});
+            success_callback->function()(MUST(load_about_version_page()).bytes(), fixme_implement_timing_info, response_headers, {}, {});
             return;
         }
 
@@ -276,12 +282,12 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
         auto resource = Core::Resource::load_from_uri(MUST(String::formatted("resource://ladybird/{}.html", url.path_segment_at_index(0))));
         if (!resource.is_error()) {
             auto data = resource.value()->data();
-            success_callback->function()(data, response_headers, {}, {});
+            success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {});
             return;
         }
 
-        Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(m_heap, [success_callback, response_headers = move(response_headers)] {
+        Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(m_heap, [success_callback, response_headers = move(response_headers), fixme_implement_timing_info = move(fixme_implement_timing_info)] {
-            success_callback->function()(ByteString::empty().to_byte_buffer(), response_headers, {}, {});
+            success_callback->function()(ByteString::empty().to_byte_buffer(), fixme_implement_timing_info, response_headers, {}, {});
         }));
         return;
     }
@@ -291,7 +297,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
         if (data_url_or_error.is_error()) {
             auto error_message = data_url_or_error.error().string_literal();
             log_failure(request, error_message);
-            error_callback->function()(error_message, {}, {}, {}, {});
+            error_callback->function()(error_message, {}, {}, {}, {}, {});
             return;
         }
         auto data_url = data_url_or_error.release_value();
@@ -306,7 +312,10 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
         log_success(request);
 
         Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(m_heap, [data = move(data_url.body), response_headers = move(response_headers), success_callback] {
-            success_callback->function()(data, response_headers, {}, {});
+            // FIXME: Implement timing info for data requests.
+            Requests::RequestTimingInfo fixme_implement_timing_info {};
+
+            success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {});
         }));
         return;
     }
@@ -316,7 +325,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
         if (resource.is_error()) {
             log_failure(request, resource.error());
             if (error_callback)
-                error_callback->function()(ByteString::formatted("{}", resource.error()), {}, {}, {}, {});
+                error_callback->function()(ByteString::formatted("{}", resource.error()), {}, {}, {}, {}, {});
             return;
         }
 
@@ -331,8 +340,11 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
         auto data = resource.value()->data();
         auto response_headers = response_headers_for_file(URL::percent_decode(url.serialize_path()), resource.value()->modified_time());
 
+        // FIXME: Implement timing info for resource requests.
+        Requests::RequestTimingInfo fixme_implement_timing_info {};
+
         log_success(request);
-        success_callback->function()(data, response_headers, {}, {});
+        success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {});
 
         return;
     }
@@ -352,7 +364,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
             if (file_or_error.is_error()) {
                 log_failure(request, file_or_error.error());
                 if (error_callback)
-                    error_callback->function()(ByteString::formatted("{}", file_or_error.error()), {}, {}, {}, {});
+                    error_callback->function()(ByteString::formatted("{}", file_or_error.error()), {}, {}, {}, {}, {});
                 return;
             }
 
@@ -369,7 +381,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
             if (st_or_error.is_error()) {
                 log_failure(request, st_or_error.error());
                 if (error_callback)
-                    error_callback->function()(ByteString::formatted("{}", st_or_error.error()), {}, {}, {}, {});
+                    error_callback->function()(ByteString::formatted("{}", st_or_error.error()), {}, {}, {}, {}, {});
                 return;
             }
 
@@ -378,7 +390,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
             if (maybe_file.is_error()) {
                 log_failure(request, maybe_file.error());
                 if (error_callback)
-                    error_callback->function()(ByteString::formatted("{}", maybe_file.error()), {}, {}, {}, {});
+                    error_callback->function()(ByteString::formatted("{}", maybe_file.error()), {}, {}, {}, {}, {});
                 return;
             }
 
@@ -387,15 +399,18 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
             if (maybe_data.is_error()) {
                 log_failure(request, maybe_data.error());
                 if (error_callback)
-                    error_callback->function()(ByteString::formatted("{}", maybe_data.error()), {}, {}, {}, {});
+                    error_callback->function()(ByteString::formatted("{}", maybe_data.error()), {}, {}, {}, {}, {});
                 return;
             }
 
             auto data = maybe_data.release_value();
             auto response_headers = response_headers_for_file(URL::percent_decode(request.url().serialize_path()), st_or_error.value().st_mtime);
 
+            // FIXME: Implement timing info for file requests.
+            Requests::RequestTimingInfo fixme_implement_timing_info {};
+
             log_success(request);
-            success_callback->function()(data, response_headers, {}, {});
+            success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {});
         });
 
         page->client().request_file(move(file_request));
@@ -411,7 +426,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
         auto protocol_request = start_network_request(request);
         if (!protocol_request) {
             if (error_callback)
-                error_callback->function()("Failed to start network request"sv, {}, {}, {}, {});
+                error_callback->function()("Failed to start network request"sv, {}, {}, {}, {}, {});
             return;
         }
 
@@ -426,7 +441,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
             timer->start();
         }
 
-        auto on_buffered_request_finished = [this, success_callback, error_callback, request, &protocol_request = *protocol_request](auto, auto const& network_error, auto& response_headers, auto status_code, auto const& reason_phrase, ReadonlyBytes payload) mutable {
+        auto on_buffered_request_finished = [this, success_callback, error_callback, request, &protocol_request = *protocol_request](auto, auto const& timing_info, auto const& network_error, auto& response_headers, auto status_code, auto const& reason_phrase, ReadonlyBytes payload) mutable {
             handle_network_response_headers(request, response_headers);
 
             // NOTE: We finish the network request *after* invoking callbacks, otherwise a nested
@@ -449,12 +464,12 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
 
                 log_failure(request, error_builder.string_view());
                 if (error_callback)
-                    error_callback->function()(error_builder.to_byte_string(), status_code, reason_phrase, payload, response_headers);
+                    error_callback->function()(error_builder.to_byte_string(), timing_info, status_code, reason_phrase, payload, response_headers);
                 return;
             }
 
             log_success(request);
-            success_callback->function()(payload, response_headers, status_code, reason_phrase);
+            success_callback->function()(payload, timing_info, response_headers, status_code, reason_phrase);
         };
 
         protocol_request->set_buffered_request_finished_callback(move(on_buffered_request_finished));
@@ -463,8 +478,9 @@ void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> succes
 
     auto not_implemented_error = ByteString::formatted("Protocol not implemented: {}", url.scheme());
     log_failure(request, not_implemented_error);
-    if (error_callback)
+    if (error_callback) {
-        error_callback->function()(not_implemented_error, {}, {}, {}, {});
+        error_callback->function()(not_implemented_error, {}, {}, {}, {}, {});
+    }
 }
 
 void ResourceLoader::load_unbuffered(LoadRequest& request, GC::Root<OnHeadersReceived> on_headers_received, GC::Root<OnDataReceived> on_data_received, GC::Root<OnComplete> on_complete)
@@ -475,19 +491,19 @@ void ResourceLoader::load_unbuffered(LoadRequest& request, GC::Root<OnHeadersRec
     request.start_timer();
 
     if (should_block_request(request)) {
-        on_complete->function()(false, "Request was blocked"sv);
+        on_complete->function()(false, {}, "Request was blocked"sv);
         return;
     }
 
     if (!url.scheme().is_one_of("http"sv, "https"sv)) {
         // FIXME: Non-network requests from fetch should not go through this path.
-        on_complete->function()(false, "Cannot establish connection non-network scheme"sv);
+        on_complete->function()(false, {}, "Cannot establish connection non-network scheme"sv);
         return;
     }
 
     auto protocol_request = start_network_request(request);
     if (!protocol_request) {
-        on_complete->function()(false, "Failed to start network request"sv);
+        on_complete->function()(false, {}, "Failed to start network request"sv);
         return;
     }
 
@@ -500,15 +516,15 @@ void ResourceLoader::load_unbuffered(LoadRequest& request, GC::Root<OnHeadersRec
         on_data_received->function()(data);
     };
 
-    auto protocol_complete = [this, on_complete, request, &protocol_request = *protocol_request](u64, Optional<Requests::NetworkError> const& network_error) {
+    auto protocol_complete = [this, on_complete, request, &protocol_request = *protocol_request](u64, Requests::RequestTimingInfo const& timing_info, Optional<Requests::NetworkError> const& network_error) {
         finish_network_request(protocol_request);
 
         if (!network_error.has_value()) {
             log_success(request);
-            on_complete->function()(true, {});
+            on_complete->function()(true, timing_info, {});
         } else {
             log_failure(request, "Request finished with error"sv);
-            on_complete->function()(false, "Request finished with error"sv);
+            on_complete->function()(false, timing_info, "Request finished with error"sv);
         }
     };
 

Libraries/LibWeb/Loader/ResourceLoader.h

@@ -26,15 +26,15 @@ public:
 
     RefPtr<Resource> load_resource(Resource::Type, LoadRequest&);
 
-    using SuccessCallback = GC::Function<void(ReadonlyBytes, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase)>;
+    using SuccessCallback = GC::Function<void(ReadonlyBytes, Requests::RequestTimingInfo const&, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase)>;
-    using ErrorCallback = GC::Function<void(ByteString const&, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes payload, HTTP::HeaderMap const& response_headers)>;
+    using ErrorCallback = GC::Function<void(ByteString const&, Requests::RequestTimingInfo const&, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes payload, HTTP::HeaderMap const& response_headers)>;
     using TimeoutCallback = GC::Function<void()>;
 
     void load(LoadRequest&, GC::Root<SuccessCallback> success_callback, GC::Root<ErrorCallback> error_callback = nullptr, Optional<u32> timeout = {}, GC::Root<TimeoutCallback> timeout_callback = nullptr);
 
     using OnHeadersReceived = GC::Function<void(HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase)>;
     using OnDataReceived = GC::Function<void(ReadonlyBytes data)>;
-    using OnComplete = GC::Function<void(bool success, Optional<StringView> error_message)>;
+    using OnComplete = GC::Function<void(bool success, Requests::RequestTimingInfo const& timing_info, Optional<StringView> error_message)>;
 
     void load_unbuffered(LoadRequest&, GC::Root<OnHeadersReceived>, GC::Root<OnDataReceived>, GC::Root<OnComplete>);
 

Services/RequestServer/ConnectionFromClient.cpp

@@ -14,6 +14,7 @@
 #include <LibCore/Proxy.h>
 #include <LibCore/Socket.h>
 #include <LibRequests/NetworkErrorEnum.h>
+#include <LibRequests/RequestTimingInfo.h>
 #include <LibRequests/WebSocket.h>
 #include <LibTLS/TLSv12.h>
 #include <LibTextCodec/Decoder.h>
@@ -382,12 +383,14 @@ void ConnectionFromClient::start_request(i32 request_id, ByteString const& metho
     m_resolver->dns.lookup(host, DNS::Messages::Class::IN, { DNS::Messages::ResourceType::A, DNS::Messages::ResourceType::AAAA })
         ->when_rejected([this, request_id](auto const& error) {
             dbgln("StartRequest: DNS lookup failed: {}", error);
-            async_request_finished(request_id, 0, Requests::NetworkError::UnableToResolveHost);
+            // FIXME: Implement timing info for DNS lookup failure.
+            async_request_finished(request_id, 0, {}, Requests::NetworkError::UnableToResolveHost);
         })
         .when_resolved([this, request_id, host, url, method, request_body, request_headers, proxy_data](auto const& dns_result) {
             if (dns_result->records().is_empty() || dns_result->cached_addresses().is_empty()) {
                 dbgln("StartRequest: DNS lookup failed for '{}'", host);
-                async_request_finished(request_id, 0, Requests::NetworkError::UnableToResolveHost);
+                // FIXME: Implement timing info for DNS lookup failure.
+                async_request_finished(request_id, 0, {}, Requests::NetworkError::UnableToResolveHost);
                 return;
             }
 
@@ -522,6 +525,75 @@ static Requests::NetworkError map_curl_code_to_network_error(CURLcode const& cod
     }
 }
 
+static Requests::RequestTimingInfo get_timing_info_from_curl_easy_handle(CURL* easy_handle)
+{
+    /*
+     *   curl_easy_perform()
+     *       |
+     *       |--QUEUE
+     *       |--|--NAMELOOKUP
+     *       |--|--|--CONNECT
+     *       |--|--|--|--APPCONNECT
+     *       |--|--|--|--|--PRETRANSFER
+     *       |--|--|--|--|--|--POSTTRANSFER
+     *       |--|--|--|--|--|--|--STARTTRANSFER
+     *       |--|--|--|--|--|--|--|--TOTAL
+     *       |--|--|--|--|--|--|--|--REDIRECT
+     */
+
+    auto get_timing_info = [easy_handle](auto option) {
+        curl_off_t time_value = 0;
+        auto result = curl_easy_getinfo(easy_handle, option, &time_value);
+        VERIFY(result == CURLE_OK);
+        return time_value;
+    };
+
+    auto queue_time = get_timing_info(CURLINFO_QUEUE_TIME_T);
+    auto domain_lookup_time = get_timing_info(CURLINFO_NAMELOOKUP_TIME_T);
+    auto connect_time = get_timing_info(CURLINFO_CONNECT_TIME_T);
+    auto secure_connect_time = get_timing_info(CURLINFO_APPCONNECT_TIME_T);
+    auto request_start_time = get_timing_info(CURLINFO_PRETRANSFER_TIME_T);
+    auto response_start_time = get_timing_info(CURLINFO_STARTTRANSFER_TIME_T);
+    auto response_end_time = get_timing_info(CURLINFO_TOTAL_TIME_T);
+    auto encoded_body_size = get_timing_info(CURLINFO_SIZE_DOWNLOAD_T);
+
+    long http_version = 0;
+    auto get_version_result = curl_easy_getinfo(easy_handle, CURLINFO_HTTP_VERSION, &http_version);
+    VERIFY(get_version_result == CURLE_OK);
+
+    auto http_version_alpn = Requests::ALPNHttpVersion::None;
+    switch (http_version) {
+    case CURL_HTTP_VERSION_1_0:
+        http_version_alpn = Requests::ALPNHttpVersion::Http1_0;
+        break;
+    case CURL_HTTP_VERSION_1_1:
+        http_version_alpn = Requests::ALPNHttpVersion::Http1_1;
+        break;
+    case CURL_HTTP_VERSION_2_0:
+        http_version_alpn = Requests::ALPNHttpVersion::Http2_TLS;
+        break;
+    case CURL_HTTP_VERSION_3:
+        http_version_alpn = Requests::ALPNHttpVersion::Http3;
+        break;
+    default:
+        http_version_alpn = Requests::ALPNHttpVersion::None;
+        break;
+    }
+
+    return Requests::RequestTimingInfo {
+        .domain_lookup_start_microseconds = queue_time,
+        .domain_lookup_end_microseconds = queue_time + domain_lookup_time,
+        .connect_start_microseconds = queue_time + domain_lookup_time,
+        .connect_end_microseconds = queue_time + domain_lookup_time + connect_time + secure_connect_time,
+        .secure_connect_start_microseconds = queue_time + domain_lookup_time + connect_time,
+        .request_start_microseconds = queue_time + domain_lookup_time + connect_time + secure_connect_time + request_start_time,
+        .response_start_microseconds = queue_time + domain_lookup_time + connect_time + secure_connect_time + response_start_time,
+        .response_end_microseconds = queue_time + domain_lookup_time + connect_time + secure_connect_time + response_end_time,
+        .encoded_body_size = encoded_body_size,
+        .http_version_alpn_identifier = http_version_alpn,
+    };
+}
+
 void ConnectionFromClient::check_active_requests()
 {
     int msgs_in_queue = 0;
@@ -547,6 +619,7 @@ void ConnectionFromClient::check_active_requests()
         auto* request = static_cast<ActiveRequest*>(application_private);
 
         if (!request->is_connect_only) {
+            auto timing_info = get_timing_info_from_curl_easy_handle(msg->easy_handle);
             request->flush_headers_if_needed();
 
             auto result_code = msg->data.result;
@@ -562,7 +635,7 @@ void ConnectionFromClient::check_active_requests()
                 }
             }
 
-            async_request_finished(request->request_id, request->downloaded_so_far, network_error);
+            async_request_finished(request->request_id, request->downloaded_so_far, timing_info, network_error);
         }
 
         m_active_requests.remove(request->request_id);

Services/RequestServer/RequestClient.ipc

@@ -1,11 +1,12 @@
 #include <LibHTTP/HeaderMap.h>
 #include <LibRequests/NetworkErrorEnum.h>
+#include <LibRequests/RequestTimingInfo.h>
 #include <LibURL/URL.h>
 
 endpoint RequestClient
 {
     request_started(i32 request_id, IPC::File fd) =|
-    request_finished(i32 request_id, u64 total_size, Optional<Requests::NetworkError> network_error) =|
+    request_finished(i32 request_id, u64 total_size, Requests::RequestTimingInfo timing_info, Optional<Requests::NetworkError> network_error) =|
     headers_became_available(i32 request_id, HTTP::HeaderMap response_headers, Optional<u32> status_code, Optional<String> reason_phrase) =|
 
     // Websocket API