mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2026-04-19 10:20:22 +00:00
31ffd2e8e5
This adds support for viewing request payloads (POST data) and response bodies in the Firefox DevTools network panel. Request bodies are captured when network requests start and passed through IPC to the NetworkEventActor, which returns them via the getRequestPostData protocol method. Response bodies are streamed via a new IPC message as data is received, accumulated in NetworkEventActor (with a 10MB size limit to prevent memory issues), and returned via getResponseContent. Text content is returned as UTF-8, while binary content (images, etc.) is base64.
534 lines
20 KiB
C++
534 lines
20 KiB
C++
/*
|
|
* Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/Enumerate.h>
|
|
#include <AK/JsonArray.h>
|
|
#include <AK/JsonObject.h>
|
|
#include <LibDevTools/Actors/AccessibilityActor.h>
|
|
#include <LibDevTools/Actors/CSSPropertiesActor.h>
|
|
#include <LibDevTools/Actors/ConsoleActor.h>
|
|
#include <LibDevTools/Actors/FrameActor.h>
|
|
#include <LibDevTools/Actors/InspectorActor.h>
|
|
#include <LibDevTools/Actors/NetworkEventActor.h>
|
|
#include <LibDevTools/Actors/StyleSheetsActor.h>
|
|
#include <LibDevTools/Actors/TabActor.h>
|
|
#include <LibDevTools/Actors/ThreadActor.h>
|
|
#include <LibDevTools/DevToolsDelegate.h>
|
|
#include <LibDevTools/DevToolsServer.h>
|
|
#include <LibWebView/ConsoleOutput.h>
|
|
|
|
namespace DevTools {
|
|
|
|
NonnullRefPtr<FrameActor> FrameActor::create(DevToolsServer& devtools, String name, WeakPtr<TabActor> tab, WeakPtr<CSSPropertiesActor> css_properties, WeakPtr<ConsoleActor> console, WeakPtr<InspectorActor> inspector, WeakPtr<StyleSheetsActor> style_sheets, WeakPtr<ThreadActor> thread, WeakPtr<AccessibilityActor> accessibility)
|
|
{
|
|
return adopt_ref(*new FrameActor(devtools, move(name), move(tab), move(css_properties), move(console), move(inspector), move(style_sheets), move(thread), move(accessibility)));
|
|
}
|
|
|
|
FrameActor::FrameActor(DevToolsServer& devtools, String name, WeakPtr<TabActor> tab, WeakPtr<CSSPropertiesActor> css_properties, WeakPtr<ConsoleActor> console, WeakPtr<InspectorActor> inspector, WeakPtr<StyleSheetsActor> style_sheets, WeakPtr<ThreadActor> thread, WeakPtr<AccessibilityActor> accessibility)
|
|
: Actor(devtools, move(name))
|
|
, m_tab(move(tab))
|
|
, m_css_properties(move(css_properties))
|
|
, m_console(move(console))
|
|
, m_inspector(move(inspector))
|
|
, m_style_sheets(move(style_sheets))
|
|
, m_thread(move(thread))
|
|
, m_accessibility(move(accessibility))
|
|
{
|
|
if (auto tab = m_tab.strong_ref()) {
|
|
devtools.delegate().listen_for_console_messages(
|
|
tab->description(),
|
|
[weak_self = make_weak_ptr<FrameActor>()](WebView::ConsoleOutput console_output) {
|
|
if (auto self = weak_self.strong_ref())
|
|
self->on_console_message(move(console_output));
|
|
});
|
|
|
|
// FIXME: We should adopt WebContent to inform us when style sheets are available or removed.
|
|
devtools.delegate().retrieve_style_sheets(tab->description(),
|
|
async_handler<FrameActor>({}, [](auto& self, auto style_sheets, auto& response) {
|
|
self.style_sheets_available(response, move(style_sheets));
|
|
}));
|
|
|
|
devtools.delegate().listen_for_network_events(
|
|
tab->description(),
|
|
[weak_self = make_weak_ptr<FrameActor>()](DevToolsDelegate::NetworkRequestData data) {
|
|
if (auto self = weak_self.strong_ref())
|
|
self->on_network_request_started(move(data));
|
|
},
|
|
[weak_self = make_weak_ptr<FrameActor>()](DevToolsDelegate::NetworkResponseData data) {
|
|
if (auto self = weak_self.strong_ref())
|
|
self->on_network_response_headers_received(move(data));
|
|
},
|
|
[weak_self = make_weak_ptr<FrameActor>()](u64 request_id, ByteBuffer data) {
|
|
if (auto self = weak_self.strong_ref())
|
|
self->on_network_response_body_received(request_id, move(data));
|
|
},
|
|
[weak_self = make_weak_ptr<FrameActor>()](DevToolsDelegate::NetworkRequestCompleteData data) {
|
|
if (auto self = weak_self.strong_ref())
|
|
self->on_network_request_finished(move(data));
|
|
});
|
|
|
|
devtools.delegate().listen_for_navigation_events(
|
|
tab->description(),
|
|
[weak_self = make_weak_ptr<FrameActor>()](String url) {
|
|
if (auto self = weak_self.strong_ref())
|
|
self->on_navigation_started(move(url));
|
|
},
|
|
[weak_self = make_weak_ptr<FrameActor>()](String url, String title) {
|
|
if (auto self = weak_self.strong_ref())
|
|
self->on_navigation_finished(move(url), move(title));
|
|
});
|
|
}
|
|
}
|
|
|
|
FrameActor::~FrameActor()
|
|
{
|
|
if (auto tab = m_tab.strong_ref()) {
|
|
devtools().delegate().stop_listening_for_console_messages(tab->description());
|
|
devtools().delegate().stop_listening_for_network_events(tab->description());
|
|
devtools().delegate().stop_listening_for_navigation_events(tab->description());
|
|
}
|
|
}
|
|
|
|
void FrameActor::handle_message(Message const& message)
|
|
{
|
|
JsonObject response;
|
|
|
|
if (message.type == "detach"sv) {
|
|
if (auto tab = m_tab.strong_ref()) {
|
|
devtools().delegate().stop_listening_for_dom_properties(tab->description());
|
|
devtools().delegate().stop_listening_for_dom_mutations(tab->description());
|
|
devtools().delegate().stop_listening_for_console_messages(tab->description());
|
|
devtools().delegate().stop_listening_for_style_sheet_sources(tab->description());
|
|
tab->reset_selected_node();
|
|
}
|
|
|
|
send_response(message, move(response));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "listFrames"sv) {
|
|
send_response(message, move(response));
|
|
return;
|
|
}
|
|
|
|
send_unrecognized_packet_type_error(message);
|
|
}
|
|
|
|
void FrameActor::send_frame_update_message()
|
|
{
|
|
JsonArray frames;
|
|
|
|
if (auto tab_actor = m_tab.strong_ref()) {
|
|
JsonObject frame;
|
|
frame.set("id"sv, tab_actor->description().id);
|
|
frame.set("title"sv, tab_actor->description().title);
|
|
frame.set("url"sv, tab_actor->description().url);
|
|
frames.must_append(move(frame));
|
|
}
|
|
|
|
JsonObject message;
|
|
message.set("type"sv, "frameUpdate"sv);
|
|
message.set("frames"sv, move(frames));
|
|
send_message(move(message));
|
|
}
|
|
|
|
JsonObject FrameActor::serialize_target() const
|
|
{
|
|
JsonObject traits;
|
|
traits.set("frames"sv, true);
|
|
traits.set("isBrowsingContext"sv, true);
|
|
traits.set("logInPage"sv, false);
|
|
traits.set("navigation"sv, true);
|
|
traits.set("supportsTopLevelTargetFlag"sv, true);
|
|
traits.set("watchpoints"sv, true);
|
|
|
|
JsonObject target;
|
|
target.set("actor"sv, name());
|
|
target.set("targetType"sv, "frame"sv);
|
|
|
|
if (auto tab_actor = m_tab.strong_ref()) {
|
|
target.set("title"sv, tab_actor->description().title);
|
|
target.set("url"sv, tab_actor->description().url);
|
|
target.set("browsingContextID"sv, tab_actor->description().id);
|
|
target.set("outerWindowID"sv, tab_actor->description().id);
|
|
target.set("isTopLevelTarget"sv, true);
|
|
}
|
|
|
|
target.set("traits"sv, move(traits));
|
|
|
|
if (auto accessibility = m_accessibility.strong_ref())
|
|
target.set("accessibilityActor"sv, accessibility->name());
|
|
if (auto console = m_console.strong_ref())
|
|
target.set("consoleActor"sv, console->name());
|
|
if (auto css_properties = m_css_properties.strong_ref())
|
|
target.set("cssPropertiesActor"sv, css_properties->name());
|
|
if (auto inspector = m_inspector.strong_ref())
|
|
target.set("inspectorActor"sv, inspector->name());
|
|
if (auto style_sheets = m_style_sheets.strong_ref())
|
|
target.set("styleSheetsActor"sv, style_sheets->name());
|
|
if (auto thread = m_thread.strong_ref())
|
|
target.set("threadActor"sv, thread->name());
|
|
|
|
return target;
|
|
}
|
|
|
|
void FrameActor::style_sheets_available(JsonObject& response, Vector<Web::CSS::StyleSheetIdentifier> style_sheets)
|
|
{
|
|
JsonArray sheets;
|
|
|
|
String tab_url;
|
|
if (auto tab_actor = m_tab.strong_ref())
|
|
tab_url = tab_actor->description().url;
|
|
|
|
auto style_sheets_actor = m_style_sheets.strong_ref();
|
|
if (!style_sheets_actor)
|
|
return;
|
|
|
|
for (auto const& [i, style_sheet] : enumerate(style_sheets)) {
|
|
auto resource_id = MUST(String::formatted("{}-stylesheet:{}", style_sheets_actor->name(), i));
|
|
|
|
JsonValue href;
|
|
JsonValue source_map_base_url;
|
|
JsonValue title;
|
|
|
|
if (style_sheet.url.has_value()) {
|
|
if (style_sheet.type == Web::CSS::StyleSheetIdentifier::Type::UserAgent) {
|
|
// LibWeb sets the URL to a style sheet name for UA style sheets. DevTools would reject these invalid URLs.
|
|
href = MUST(String::formatted("resource://{}", style_sheet.url.value()));
|
|
title = *style_sheet.url;
|
|
source_map_base_url = tab_url;
|
|
} else if (style_sheet.type == Web::CSS::StyleSheetIdentifier::Type::StyleElement) {
|
|
source_map_base_url = *style_sheet.url;
|
|
} else {
|
|
href = *style_sheet.url;
|
|
source_map_base_url = *style_sheet.url;
|
|
}
|
|
} else {
|
|
source_map_base_url = tab_url;
|
|
}
|
|
|
|
JsonObject sheet;
|
|
sheet.set("atRules"sv, JsonArray {});
|
|
sheet.set("constructed"sv, false);
|
|
sheet.set("disabled"sv, false);
|
|
sheet.set("fileName"sv, JsonValue {});
|
|
sheet.set("href"sv, move(href));
|
|
sheet.set("isNew"sv, false);
|
|
sheet.set("nodeHref"sv, tab_url);
|
|
sheet.set("resourceId"sv, move(resource_id));
|
|
sheet.set("ruleCount"sv, style_sheet.rule_count);
|
|
sheet.set("sourceMapBaseURL"sv, move(source_map_base_url));
|
|
sheet.set("sourceMapURL"sv, ""sv);
|
|
sheet.set("styleSheetIndex"sv, i);
|
|
sheet.set("system"sv, style_sheet.type == Web::CSS::StyleSheetIdentifier::Type::UserAgent);
|
|
sheet.set("title"sv, move(title));
|
|
|
|
sheets.must_append(move(sheet));
|
|
}
|
|
|
|
JsonArray stylesheets;
|
|
stylesheets.must_append("stylesheet"sv);
|
|
stylesheets.must_append(move(sheets));
|
|
|
|
JsonArray array;
|
|
array.must_append(move(stylesheets));
|
|
|
|
response.set("type"sv, "resources-available-array"sv);
|
|
response.set("array"sv, move(array));
|
|
|
|
style_sheets_actor->set_style_sheets(move(style_sheets));
|
|
}
|
|
|
|
void FrameActor::on_console_message(WebView::ConsoleOutput console_output)
|
|
{
|
|
JsonArray console_messages;
|
|
JsonArray error_messages;
|
|
|
|
JsonObject message;
|
|
|
|
console_output.output.visit(
|
|
[&](WebView::ConsoleLog& log) {
|
|
switch (log.level) {
|
|
case JS::Console::LogLevel::Debug:
|
|
message.set("level"sv, "debug"sv);
|
|
break;
|
|
case JS::Console::LogLevel::Error:
|
|
message.set("level"sv, "error"sv);
|
|
break;
|
|
case JS::Console::LogLevel::Info:
|
|
message.set("level"sv, "info"sv);
|
|
break;
|
|
case JS::Console::LogLevel::Log:
|
|
message.set("level"sv, "log"sv);
|
|
break;
|
|
case JS::Console::LogLevel::Warn:
|
|
message.set("level"sv, "warn"sv);
|
|
break;
|
|
default:
|
|
// FIXME: Implement remaining console levels.
|
|
return;
|
|
}
|
|
|
|
message.set("filename"sv, "<eval>"sv);
|
|
message.set("lineNumber"sv, 1);
|
|
message.set("columnNumber"sv, 1);
|
|
message.set("timeStamp"sv, console_output.timestamp.milliseconds_since_epoch());
|
|
message.set("arguments"sv, JsonArray { move(log.arguments) });
|
|
|
|
console_messages.must_append(move(message));
|
|
},
|
|
[&](WebView::ConsoleError const& error) {
|
|
StringBuilder stack;
|
|
|
|
for (auto const& frame : error.trace) {
|
|
if (frame.function.has_value())
|
|
stack.append(*frame.function);
|
|
stack.append('@');
|
|
stack.append(frame.file.map([](auto const& file) -> StringView { return file; }).value_or("unknown"sv));
|
|
stack.appendff(":{}:{}\n", frame.line.value_or(0), frame.column.value_or(0));
|
|
}
|
|
|
|
JsonObject preview;
|
|
preview.set("kind"sv, "Error"sv);
|
|
preview.set("message"sv, error.message);
|
|
preview.set("name"sv, error.name);
|
|
if (!stack.is_empty())
|
|
preview.set("stack"sv, MUST(stack.to_string()));
|
|
|
|
JsonObject exception;
|
|
exception.set("class"sv, error.name);
|
|
exception.set("isError"sv, true);
|
|
exception.set("preview"sv, move(preview));
|
|
|
|
JsonObject page_error;
|
|
page_error.set("error"sv, true);
|
|
page_error.set("exception"sv, move(exception));
|
|
page_error.set("hasException"sv, !error.trace.is_empty());
|
|
page_error.set("isPromiseRejection"sv, error.inside_promise);
|
|
page_error.set("timeStamp"sv, console_output.timestamp.milliseconds_since_epoch());
|
|
|
|
message.set("pageError"sv, move(page_error));
|
|
error_messages.must_append(move(message));
|
|
});
|
|
|
|
JsonArray array;
|
|
|
|
if (!console_messages.is_empty()) {
|
|
JsonArray console_message;
|
|
console_message.must_append("console-message"sv);
|
|
console_message.must_append(move(console_messages));
|
|
|
|
array.must_append(move(console_message));
|
|
}
|
|
if (!error_messages.is_empty()) {
|
|
JsonArray error_message;
|
|
error_message.must_append("error-message"sv);
|
|
error_message.must_append(move(error_messages));
|
|
|
|
array.must_append(move(error_message));
|
|
}
|
|
|
|
if (array.is_empty())
|
|
return;
|
|
|
|
JsonObject resources_message;
|
|
resources_message.set("type"sv, "resources-available-array"sv);
|
|
resources_message.set("array"sv, move(array));
|
|
send_message(move(resources_message));
|
|
}
|
|
|
|
void FrameActor::on_network_request_started(DevToolsDelegate::NetworkRequestData data)
|
|
{
|
|
auto& actor = devtools().register_actor<NetworkEventActor>(data.request_id);
|
|
actor.set_request_info(move(data.url), move(data.method), data.start_time, move(data.request_headers), move(data.request_body));
|
|
m_network_events.set(data.request_id, actor);
|
|
|
|
JsonArray events;
|
|
events.must_append(actor.serialize_initial_event());
|
|
|
|
JsonArray network_event;
|
|
network_event.must_append("network-event"sv);
|
|
network_event.must_append(move(events));
|
|
|
|
JsonArray array;
|
|
array.must_append(move(network_event));
|
|
|
|
JsonObject message;
|
|
message.set("type"sv, "resources-available-array"sv);
|
|
message.set("array"sv, move(array));
|
|
send_message(move(message));
|
|
}
|
|
|
|
void FrameActor::on_network_response_headers_received(DevToolsDelegate::NetworkResponseData data)
|
|
{
|
|
auto it = m_network_events.find(data.request_id);
|
|
if (it == m_network_events.end())
|
|
return;
|
|
|
|
auto& actor = *it->value;
|
|
actor.set_response_start(data.status_code, data.reason_phrase);
|
|
|
|
// Extract Content-Type before moving headers
|
|
String mime_type;
|
|
i64 headers_size = 0;
|
|
for (auto const& header : data.response_headers) {
|
|
headers_size += static_cast<i64>(header.name.bytes().size() + header.value.bytes().size() + 4);
|
|
if (header.name.equals_ignoring_ascii_case("content-type"sv))
|
|
mime_type = MUST(String::from_byte_string(header.value));
|
|
}
|
|
|
|
actor.set_response_headers(move(data.response_headers));
|
|
|
|
// Build resource updates object
|
|
JsonObject resource_updates;
|
|
resource_updates.set("status"sv, String::number(data.status_code));
|
|
resource_updates.set("statusText"sv, data.reason_phrase.value_or(String {}));
|
|
resource_updates.set("headersSize"sv, headers_size);
|
|
resource_updates.set("mimeType"sv, mime_type);
|
|
// FIXME: Get actual HTTP version from response
|
|
resource_updates.set("httpVersion"sv, "HTTP/1.1"sv);
|
|
// FIXME: Get actual remote address and port from connection
|
|
resource_updates.set("remoteAddress"sv, String {});
|
|
resource_updates.set("remotePort"sv, 0);
|
|
// FIXME: Calculate actual waiting time (time between request sent and first byte received)
|
|
resource_updates.set("waitingTime"sv, 0);
|
|
// Mark headers as available
|
|
resource_updates.set("responseHeadersAvailable"sv, true);
|
|
|
|
JsonObject update_entry;
|
|
update_entry.set("resourceId"sv, static_cast<i64>(data.request_id));
|
|
update_entry.set("resourceType"sv, "network-event"sv);
|
|
update_entry.set("resourceUpdates"sv, move(resource_updates));
|
|
update_entry.set("browsingContextID"sv, 1);
|
|
update_entry.set("innerWindowId"sv, 1);
|
|
|
|
JsonArray updates;
|
|
updates.must_append(move(update_entry));
|
|
|
|
JsonArray network_event_updates;
|
|
network_event_updates.must_append("network-event"sv);
|
|
network_event_updates.must_append(move(updates));
|
|
|
|
JsonArray array;
|
|
array.must_append(move(network_event_updates));
|
|
|
|
JsonObject message;
|
|
message.set("type"sv, "resources-updated-array"sv);
|
|
message.set("array"sv, move(array));
|
|
send_message(move(message));
|
|
}
|
|
|
|
void FrameActor::on_network_response_body_received(u64 request_id, ByteBuffer data)
|
|
{
|
|
auto it = m_network_events.find(request_id);
|
|
if (it == m_network_events.end())
|
|
return;
|
|
|
|
it->value->append_response_body(move(data));
|
|
}
|
|
|
|
void FrameActor::on_network_request_finished(DevToolsDelegate::NetworkRequestCompleteData data)
|
|
{
|
|
auto it = m_network_events.find(data.request_id);
|
|
if (it == m_network_events.end())
|
|
return;
|
|
|
|
auto& actor = *it->value;
|
|
actor.set_request_complete(data.body_size, data.timing_info, data.network_error);
|
|
|
|
// Calculate total time in milliseconds
|
|
auto total_time = (data.timing_info.response_end_microseconds - data.timing_info.request_start_microseconds) / 1000;
|
|
|
|
// Build resource updates object with content and timing info
|
|
JsonObject resource_updates;
|
|
resource_updates.set("contentSize"sv, static_cast<i64>(data.body_size));
|
|
resource_updates.set("transferredSize"sv, static_cast<i64>(data.body_size));
|
|
resource_updates.set("totalTime"sv, total_time);
|
|
// Mark as complete
|
|
resource_updates.set("responseContentAvailable"sv, true);
|
|
resource_updates.set("eventTimingsAvailable"sv, true);
|
|
|
|
JsonObject update_entry;
|
|
update_entry.set("resourceId"sv, static_cast<i64>(data.request_id));
|
|
update_entry.set("resourceType"sv, "network-event"sv);
|
|
update_entry.set("resourceUpdates"sv, move(resource_updates));
|
|
update_entry.set("browsingContextID"sv, 1);
|
|
update_entry.set("innerWindowId"sv, 1);
|
|
|
|
JsonArray updates;
|
|
updates.must_append(move(update_entry));
|
|
|
|
JsonArray network_event_updates;
|
|
network_event_updates.must_append("network-event"sv);
|
|
network_event_updates.must_append(move(updates));
|
|
|
|
JsonArray array;
|
|
array.must_append(move(network_event_updates));
|
|
|
|
JsonObject message;
|
|
message.set("type"sv, "resources-updated-array"sv);
|
|
message.set("array"sv, move(array));
|
|
send_message(move(message));
|
|
}
|
|
|
|
void FrameActor::on_navigation_started(String url)
|
|
{
|
|
// Clear our internal tracking of network events
|
|
m_network_events.clear();
|
|
|
|
// Send will-navigate document event to trigger network panel clear
|
|
JsonObject document_event;
|
|
document_event.set("resourceType"sv, "document-event"sv);
|
|
document_event.set("name"sv, "will-navigate"sv);
|
|
document_event.set("time"sv, UnixDateTime::now().milliseconds_since_epoch());
|
|
document_event.set("newURI"sv, url);
|
|
document_event.set("isFrameSwitching"sv, false);
|
|
|
|
JsonArray events;
|
|
events.must_append(move(document_event));
|
|
|
|
JsonArray document_event_array;
|
|
document_event_array.must_append("document-event"sv);
|
|
document_event_array.must_append(move(events));
|
|
|
|
JsonArray array;
|
|
array.must_append(move(document_event_array));
|
|
|
|
JsonObject resources_message;
|
|
resources_message.set("type"sv, "resources-available-array"sv);
|
|
resources_message.set("array"sv, move(array));
|
|
send_message(move(resources_message));
|
|
|
|
// Also send tabNavigated for backwards compatibility
|
|
JsonObject message;
|
|
message.set("type"sv, "tabNavigated"sv);
|
|
message.set("url"sv, move(url));
|
|
message.set("state"sv, "start"sv);
|
|
message.set("isFrameSwitching"sv, false);
|
|
send_message(move(message));
|
|
}
|
|
|
|
void FrameActor::on_navigation_finished(String url, String title)
|
|
{
|
|
// Update the tab description with the new URL and title
|
|
if (auto tab = m_tab.strong_ref()) {
|
|
tab->set_url(url);
|
|
tab->set_title(title);
|
|
}
|
|
|
|
JsonObject message;
|
|
message.set("type"sv, "tabNavigated"sv);
|
|
message.set("url"sv, move(url));
|
|
message.set("title"sv, move(title));
|
|
message.set("state"sv, "stop"sv);
|
|
message.set("isFrameSwitching"sv, false);
|
|
send_message(move(message));
|
|
|
|
// Also send a frameUpdate message to update the frame info
|
|
send_frame_update_message();
|
|
}
|
|
|
|
}
|