mirror of
https://github.com/zebrajr/ladybird.git
synced 2025-12-06 12:20:00 +01:00
41b4292447
This is enough for Firefox to display the Accessibility tab, containing our accessibility tree which can be inspected. Most information is blank for now. There's quite a bit of duplication between AccessibilityWalkerActor and WalkerActor - it might be worth trying to make a base class once the details are figured out. Frustratingly, the two don't work quite the same: for a lot of messages that would be sent to WalkerActor, the accessibility equivalent is sent to the AccessibilityNodeActor instead. Co-authored-by: Tim Flynn <trflynn89@pm.me>
808 lines
28 KiB
C++
808 lines
28 KiB
C++
/*
|
|
* Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/JsonArray.h>
|
|
#include <AK/StringUtils.h>
|
|
#include <LibDevTools/Actors/AccessibilityNodeActor.h>
|
|
#include <LibDevTools/Actors/LayoutInspectorActor.h>
|
|
#include <LibDevTools/Actors/TabActor.h>
|
|
#include <LibDevTools/Actors/WalkerActor.h>
|
|
#include <LibDevTools/DevToolsDelegate.h>
|
|
#include <LibDevTools/DevToolsServer.h>
|
|
#include <LibWeb/DOM/NodeType.h>
|
|
#include <LibWebView/Mutation.h>
|
|
|
|
namespace DevTools {
|
|
|
|
NonnullRefPtr<WalkerActor> WalkerActor::create(DevToolsServer& devtools, String name, WeakPtr<TabActor> tab, JsonObject dom_tree)
|
|
{
|
|
return adopt_ref(*new WalkerActor(devtools, move(name), move(tab), move(dom_tree)));
|
|
}
|
|
|
|
WalkerActor::WalkerActor(DevToolsServer& devtools, String name, WeakPtr<TabActor> tab, JsonObject dom_tree)
|
|
: Actor(devtools, move(name))
|
|
, m_tab(move(tab))
|
|
, m_dom_tree(move(dom_tree))
|
|
{
|
|
populate_dom_tree_cache();
|
|
|
|
if (auto tab = m_tab.strong_ref()) {
|
|
devtools.delegate().listen_for_dom_mutations(tab->description(),
|
|
[weak_self = make_weak_ptr<WalkerActor>()](WebView::Mutation mutation) {
|
|
if (auto self = weak_self.strong_ref())
|
|
self->new_dom_node_mutation(move(mutation));
|
|
});
|
|
}
|
|
}
|
|
|
|
WalkerActor::~WalkerActor()
|
|
{
|
|
if (auto tab = m_tab.strong_ref())
|
|
devtools().delegate().stop_listening_for_dom_mutations(tab->description());
|
|
}
|
|
|
|
void WalkerActor::handle_message(Message const& message)
|
|
{
|
|
JsonObject response;
|
|
|
|
if (message.type == "children"sv) {
|
|
auto node = get_required_parameter<String>(message, "node"sv);
|
|
if (!node.has_value())
|
|
return;
|
|
|
|
auto ancestor_node = WalkerActor::dom_node_for(*this, *node);
|
|
if (!ancestor_node.has_value()) {
|
|
send_unknown_actor_error(message, *node);
|
|
return;
|
|
}
|
|
|
|
JsonArray nodes;
|
|
|
|
if (auto children = ancestor_node->node.get_array("children"sv); children.has_value()) {
|
|
children->for_each([&](JsonValue const& child) {
|
|
nodes.must_append(serialize_node(child.as_object()));
|
|
});
|
|
}
|
|
|
|
response.set("hasFirst"sv, !nodes.is_empty());
|
|
response.set("hasLast"sv, !nodes.is_empty());
|
|
response.set("nodes"sv, move(nodes));
|
|
send_response(message, move(response));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "duplicateNode"sv) {
|
|
auto node = get_required_parameter<String>(message, "node"sv);
|
|
if (!node.has_value())
|
|
return;
|
|
|
|
auto dom_node = WalkerActor::dom_node_for(*this, *node);
|
|
if (!dom_node.has_value()) {
|
|
send_unknown_actor_error(message, *node);
|
|
return;
|
|
}
|
|
|
|
devtools().delegate().clone_dom_node(dom_node->tab->description(), dom_node->identifier.id, default_async_handler(message));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "editTagName"sv) {
|
|
auto node = get_required_parameter<String>(message, "node"sv);
|
|
if (!node.has_value())
|
|
return;
|
|
|
|
auto tag_name = get_required_parameter<String>(message, "tagName"sv);
|
|
if (!tag_name.has_value())
|
|
return;
|
|
|
|
auto dom_node = WalkerActor::dom_node_for(*this, *node);
|
|
if (!dom_node.has_value()) {
|
|
send_unknown_actor_error(message, *node);
|
|
return;
|
|
}
|
|
|
|
devtools().delegate().set_dom_node_tag(dom_node->tab->description(), dom_node->identifier.id, *tag_name, default_async_handler(message));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "getLayoutInspector"sv) {
|
|
if (!m_layout_inspector)
|
|
m_layout_inspector = devtools().register_actor<LayoutInspectorActor>();
|
|
|
|
JsonObject actor;
|
|
actor.set("actor"sv, m_layout_inspector->name());
|
|
|
|
response.set("actor"sv, move(actor));
|
|
send_response(message, move(response));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "getMutations"sv) {
|
|
response.set("mutations"sv, serialize_mutations());
|
|
send_response(message, move(response));
|
|
|
|
m_has_new_mutations_since_last_mutations_request = false;
|
|
return;
|
|
}
|
|
|
|
if (message.type == "getNodeFromActor"sv) {
|
|
auto path = get_required_parameter<JsonArray>(message, "path"sv);
|
|
if (!path.has_value())
|
|
return;
|
|
|
|
auto actor_id = get_required_parameter<String>(message, "actorID"sv);
|
|
if (!actor_id.has_value())
|
|
return;
|
|
|
|
// The ["rawAccessible","DOMNode"] path retrieves the DOM node corresponding to an AccessibilityNodeActor.
|
|
if (path->size() == 2) {
|
|
auto const& first = path->at(0);
|
|
auto const& second = path->at(1);
|
|
if (first.is_string() && first.as_string() == "rawAccessible"sv
|
|
&& second.is_string() && second.as_string() == "DOMNode"sv) {
|
|
|
|
auto maybe_accessibility_actor = devtools().actor_registry().find(actor_id.value());
|
|
if (maybe_accessibility_actor == devtools().actor_registry().end()) {
|
|
send_unknown_actor_error(message, actor_id.value());
|
|
return;
|
|
}
|
|
|
|
auto accessibility_actor = as<AccessibilityNodeActor>(maybe_accessibility_actor->value.ptr());
|
|
if (auto node_actor_name = m_dom_node_id_to_actor_map.get(accessibility_actor->node_identifier().id); node_actor_name.has_value()) {
|
|
auto dom_node = dom_node_for(this, node_actor_name.value());
|
|
if (!dom_node.has_value()) {
|
|
send_unknown_actor_error(message, node_actor_name.value());
|
|
return;
|
|
}
|
|
|
|
JsonObject node;
|
|
node.set("node"sv, serialize_node(dom_node->node));
|
|
node.set("newParents"sv, JsonArray {});
|
|
|
|
response.set("node"sv, move(node));
|
|
send_response(message, move(response));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
JsonObject error;
|
|
error.set("error"sv, "unrecognizedNodePath"sv);
|
|
error.set("message"sv, MUST(String::formatted("Unrecognized or missing path for getNodeFromActor: '{}'", message.data.serialized())));
|
|
send_response(message, move(error));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "getOffsetParent"sv) {
|
|
response.set("node"sv, JsonValue {});
|
|
send_response(message, move(response));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "innerHTML"sv) {
|
|
auto node = get_required_parameter<String>(message, "node"sv);
|
|
if (!node.has_value())
|
|
return;
|
|
|
|
auto dom_node = WalkerActor::dom_node_for(*this, *node);
|
|
if (!dom_node.has_value()) {
|
|
send_unknown_actor_error(message, *node);
|
|
return;
|
|
}
|
|
|
|
devtools().delegate().get_dom_node_inner_html(dom_node->tab->description(), dom_node->identifier.id,
|
|
async_handler(message, [](auto&, auto html, auto& response) {
|
|
response.set("value"sv, move(html));
|
|
}));
|
|
|
|
return;
|
|
}
|
|
|
|
if (message.type == "insertAdjacentHTML") {
|
|
// FIXME: This message also contains `value` and `position` parameters, containing the HTML to insert and the
|
|
// location to insert it. For the "Create New Node" action, this is always "<div></div>" and "beforeEnd",
|
|
// which is exactly what our WebView implementation currently supports.
|
|
auto node = get_required_parameter<String>(message, "node"sv);
|
|
if (!node.has_value())
|
|
return;
|
|
|
|
auto dom_node = WalkerActor::dom_node_for(*this, *node);
|
|
if (!dom_node.has_value()) {
|
|
send_unknown_actor_error(message, *node);
|
|
return;
|
|
}
|
|
|
|
devtools().delegate().create_child_element(dom_node->tab->description(), dom_node->identifier.id,
|
|
async_handler<WalkerActor>(message, [](auto& self, auto node_id, auto& response) {
|
|
JsonArray nodes;
|
|
|
|
if (auto actor = self.m_dom_node_id_to_actor_map.get(node_id); actor.has_value()) {
|
|
if (auto dom_node = WalkerActor::dom_node_for(self, *actor); dom_node.has_value())
|
|
nodes.must_append(self.serialize_node(dom_node->node));
|
|
}
|
|
|
|
response.set("newParents"sv, JsonArray {});
|
|
response.set("nodes"sv, move(nodes));
|
|
}));
|
|
|
|
return;
|
|
}
|
|
|
|
if (message.type == "insertBefore"sv) {
|
|
auto node = get_required_parameter<String>(message, "node"sv);
|
|
if (!node.has_value())
|
|
return;
|
|
|
|
auto parent = get_required_parameter<String>(message, "parent"sv);
|
|
if (!parent.has_value())
|
|
return;
|
|
|
|
auto dom_node = WalkerActor::dom_node_for(*this, *node);
|
|
if (!dom_node.has_value()) {
|
|
send_unknown_actor_error(message, *node);
|
|
return;
|
|
}
|
|
|
|
auto parent_dom_node = WalkerActor::dom_node_for(*this, *parent);
|
|
if (!parent_dom_node.has_value()) {
|
|
send_unknown_actor_error(message, *parent);
|
|
return;
|
|
}
|
|
|
|
Optional<Web::UniqueNodeID> sibling_node_id;
|
|
if (auto sibling = message.data.get_string("sibling"sv); sibling.has_value()) {
|
|
auto sibling_dom_node = WalkerActor::dom_node_for(*this, *sibling);
|
|
if (!sibling_dom_node.has_value()) {
|
|
send_unknown_actor_error(message, *sibling);
|
|
return;
|
|
}
|
|
|
|
sibling_node_id = sibling_dom_node->identifier.id;
|
|
}
|
|
|
|
devtools().delegate().insert_dom_node_before(dom_node->tab->description(), dom_node->identifier.id, parent_dom_node->identifier.id, sibling_node_id, default_async_handler(message));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "isInDOMTree"sv) {
|
|
auto node = get_required_parameter<String>(message, "node"sv);
|
|
if (!node.has_value())
|
|
return;
|
|
|
|
response.set("attached"sv, m_actor_to_dom_node_map.contains(*node));
|
|
send_response(message, move(response));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "outerHTML"sv) {
|
|
auto node = get_required_parameter<String>(message, "node"sv);
|
|
if (!node.has_value())
|
|
return;
|
|
|
|
auto dom_node = WalkerActor::dom_node_for(*this, *node);
|
|
if (!dom_node.has_value()) {
|
|
send_unknown_actor_error(message, *node);
|
|
return;
|
|
}
|
|
|
|
devtools().delegate().get_dom_node_outer_html(dom_node->tab->description(), dom_node->identifier.id,
|
|
async_handler(message, [](auto&, auto html, auto& response) {
|
|
response.set("value"sv, move(html));
|
|
}));
|
|
|
|
return;
|
|
}
|
|
|
|
if (message.type == "previousSibling"sv) {
|
|
auto node = get_required_parameter<String>(message, "node"sv);
|
|
if (!node.has_value())
|
|
return;
|
|
|
|
auto dom_node = WalkerActor::dom_node_for(*this, *node);
|
|
if (!dom_node.has_value()) {
|
|
send_unknown_actor_error(message, *node);
|
|
return;
|
|
}
|
|
|
|
JsonValue previous_sibling;
|
|
if (auto previous_sibling_node = previous_sibling_for_node(dom_node->node); previous_sibling_node.has_value())
|
|
previous_sibling = serialize_node(*previous_sibling_node);
|
|
|
|
response.set("node"sv, move(previous_sibling));
|
|
send_response(message, move(response));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "querySelector"sv) {
|
|
auto node = get_required_parameter<String>(message, "node"sv);
|
|
if (!node.has_value())
|
|
return;
|
|
|
|
auto selector = get_required_parameter<String>(message, "selector"sv);
|
|
if (!selector.has_value())
|
|
return;
|
|
|
|
auto ancestor_node = WalkerActor::dom_node_for(*this, *node);
|
|
if (!ancestor_node.has_value()) {
|
|
send_unknown_actor_error(message, *node);
|
|
return;
|
|
}
|
|
|
|
if (auto selected_node = find_node_by_selector(ancestor_node->node, *selector); selected_node.has_value()) {
|
|
response.set("node"sv, serialize_node(*selected_node));
|
|
|
|
if (auto parent = m_dom_node_to_parent_map.get(&selected_node.value()); parent.value() && parent.value() != &ancestor_node->node) {
|
|
// FIXME: Should this be a stack of nodes leading to `ancestor_node`?
|
|
JsonArray new_parents;
|
|
new_parents.must_append(serialize_node(*parent.value()));
|
|
|
|
response.set("newParents"sv, move(new_parents));
|
|
}
|
|
}
|
|
|
|
send_response(message, move(response));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "removeNode"sv) {
|
|
auto node = get_required_parameter<String>(message, "node"sv);
|
|
if (!node.has_value())
|
|
return;
|
|
|
|
auto dom_node = WalkerActor::dom_node_for(*this, *node);
|
|
if (!dom_node.has_value()) {
|
|
send_unknown_actor_error(message, *node);
|
|
return;
|
|
}
|
|
|
|
JsonValue next_sibling;
|
|
if (auto next_sibling_node = next_sibling_for_node(dom_node->node); next_sibling_node.has_value())
|
|
next_sibling = serialize_node(*next_sibling_node);
|
|
|
|
auto parent_node = remove_node(dom_node->node);
|
|
if (!parent_node.has_value())
|
|
return;
|
|
|
|
devtools().delegate().remove_dom_node(dom_node->tab->description(), dom_node->identifier.id,
|
|
async_handler(message, [next_sibling = move(next_sibling)](auto&, auto, auto& response) mutable {
|
|
response.set("nextSibling"sv, move(next_sibling));
|
|
}));
|
|
|
|
return;
|
|
}
|
|
|
|
if (message.type == "retainNode"sv) {
|
|
send_response(message, move(response));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "setOuterHTML"sv) {
|
|
auto node = get_required_parameter<String>(message, "node"sv);
|
|
if (!node.has_value())
|
|
return;
|
|
|
|
auto value = get_required_parameter<String>(message, "value"sv);
|
|
if (!value.has_value())
|
|
return;
|
|
|
|
auto dom_node = WalkerActor::dom_node_for(*this, *node);
|
|
if (!dom_node.has_value()) {
|
|
send_unknown_actor_error(message, *node);
|
|
return;
|
|
}
|
|
|
|
devtools().delegate().set_dom_node_outer_html(dom_node->tab->description(), dom_node->identifier.id, value.release_value(), default_async_handler(message));
|
|
return;
|
|
}
|
|
|
|
if (message.type == "watchRootNode"sv) {
|
|
response.set("type"sv, "root-available"sv);
|
|
response.set("node"sv, serialize_root());
|
|
send_response(message, move(response));
|
|
|
|
send_message({});
|
|
return;
|
|
}
|
|
|
|
send_unrecognized_packet_type_error(message);
|
|
}
|
|
|
|
bool WalkerActor::is_suitable_for_dom_inspection(JsonValue const& node)
|
|
{
|
|
if (!node.is_object())
|
|
return true;
|
|
|
|
auto const& object = node.as_object();
|
|
|
|
if (!object.has_string("name"sv) || !object.has_string("type"sv))
|
|
return false;
|
|
|
|
if (auto text = object.get_string("text"sv); text.has_value()) {
|
|
if (AK::StringUtils::is_whitespace(*text))
|
|
return false;
|
|
}
|
|
if (auto data = object.get_string("data"sv); data.has_value()) {
|
|
if (AK::StringUtils::is_whitespace(*data))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
JsonValue WalkerActor::serialize_root() const
|
|
{
|
|
return serialize_node(m_dom_tree);
|
|
}
|
|
|
|
JsonValue WalkerActor::serialize_node(JsonObject const& node) const
|
|
{
|
|
auto tab = m_tab.strong_ref();
|
|
if (!tab)
|
|
return {};
|
|
|
|
auto actor = node.get_string("actor"sv);
|
|
if (!actor.has_value())
|
|
return {};
|
|
|
|
auto name = node.get_string("name"sv).release_value();
|
|
auto type = node.get_string("type"sv).release_value();
|
|
|
|
auto dom_type = parse_dom_node_type(type);
|
|
JsonValue node_value;
|
|
|
|
auto is_top_level_document = &node == &m_dom_tree;
|
|
auto is_displayed = !is_top_level_document && node.get_bool("visible"sv).value_or(false);
|
|
auto is_scrollable = node.get_bool("scrollable"sv).value_or(false);
|
|
|
|
auto is_shadow_root = false;
|
|
auto is_after_pseudo_element = false;
|
|
auto is_before_pseudo_element = false;
|
|
auto is_marker_pseudo_element = false;
|
|
|
|
if (dom_type == Web::DOM::NodeType::TEXT_NODE) {
|
|
if (auto text = node.get_string("text"sv); text.has_value())
|
|
node_value = text.release_value();
|
|
} else if (dom_type == Web::DOM::NodeType::COMMENT_NODE) {
|
|
if (auto data = node.get_string("data"sv); data.has_value())
|
|
node_value = data.release_value();
|
|
}
|
|
|
|
if (type == "shadow-root"sv) {
|
|
is_shadow_root = true;
|
|
} else if (type == "pseudo-element"sv) {
|
|
auto pseudo_element = node.get_integer<UnderlyingType<Web::CSS::PseudoElement>>("pseudo-element"sv).map([](auto value) {
|
|
VERIFY(value < to_underlying(Web::CSS::PseudoElement::KnownPseudoElementCount));
|
|
return static_cast<Web::CSS::PseudoElement>(value);
|
|
});
|
|
|
|
is_after_pseudo_element = pseudo_element == Web::CSS::PseudoElement::After;
|
|
is_before_pseudo_element = pseudo_element == Web::CSS::PseudoElement::Before;
|
|
is_marker_pseudo_element = pseudo_element == Web::CSS::PseudoElement::Marker;
|
|
|
|
auto parent_id = node.get_integer<Web::UniqueNodeID::Type>("parent-id"sv).value();
|
|
|
|
if (auto parent_actor = m_dom_node_id_to_actor_map.get(parent_id); parent_actor.has_value()) {
|
|
if (auto parent_node = WalkerActor::dom_node_for(this, *parent_actor); parent_node.has_value()) {
|
|
dom_type = parse_dom_node_type(parent_node->node.get_string("type"sv).value());
|
|
is_displayed = !is_top_level_document && parent_node->node.get_bool("visible"sv).value_or(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t child_count = 0;
|
|
if (auto children = node.get_array("children"sv); children.has_value())
|
|
child_count = children->size();
|
|
|
|
JsonArray attrs;
|
|
|
|
if (auto attributes = node.get_object("attributes"sv); attributes.has_value()) {
|
|
attributes->for_each_member([&](String const& name, JsonValue const& value) {
|
|
if (!value.is_string())
|
|
return;
|
|
|
|
JsonObject attr;
|
|
attr.set("name"sv, name);
|
|
attr.set("value"sv, value.as_string());
|
|
attrs.must_append(move(attr));
|
|
});
|
|
}
|
|
|
|
JsonObject serialized;
|
|
serialized.set("actor"sv, actor.release_value());
|
|
serialized.set("attrs"sv, move(attrs));
|
|
serialized.set("baseURI"sv, tab->description().url);
|
|
serialized.set("causesOverflow"sv, false);
|
|
serialized.set("containerType"sv, JsonValue {});
|
|
serialized.set("displayName"sv, name.to_ascii_lowercase());
|
|
serialized.set("displayType"sv, "block"sv);
|
|
serialized.set("hasEventListeners"sv, false);
|
|
serialized.set("isAfterPseudoElement"sv, is_after_pseudo_element);
|
|
serialized.set("isAnonymous"sv, false);
|
|
serialized.set("isBeforePseudoElement"sv, is_before_pseudo_element);
|
|
serialized.set("isDirectShadowHostChild"sv, JsonValue {});
|
|
serialized.set("isDisplayed"sv, is_displayed);
|
|
serialized.set("isInHTMLDocument"sv, true);
|
|
serialized.set("isMarkerPseudoElement"sv, is_marker_pseudo_element);
|
|
serialized.set("isNativeAnonymous"sv, false);
|
|
serialized.set("isScrollable"sv, is_scrollable);
|
|
serialized.set("isShadowHost"sv, false);
|
|
serialized.set("isShadowRoot"sv, is_shadow_root);
|
|
serialized.set("isTopLevelDocument"sv, is_top_level_document);
|
|
serialized.set("nodeName"sv, name);
|
|
serialized.set("nodeType"sv, to_underlying(dom_type));
|
|
serialized.set("nodeValue"sv, move(node_value));
|
|
serialized.set("numChildren"sv, child_count);
|
|
serialized.set("shadowRootMode"sv, JsonValue {});
|
|
serialized.set("traits"sv, JsonObject {});
|
|
|
|
// FIXME: De-duplicate this string. LibDevTools currently cannot depend on LibWeb.
|
|
serialized.set("namespaceURI"sv, "http://www.w3.org/1999/xhtml"sv);
|
|
|
|
if (!is_top_level_document) {
|
|
if (auto parent = m_dom_node_to_parent_map.get(&node); parent.has_value() && parent.value()) {
|
|
actor = parent.value()->get_string("actor"sv);
|
|
if (!actor.has_value())
|
|
return {};
|
|
|
|
serialized.set("parent"sv, actor.release_value());
|
|
}
|
|
}
|
|
|
|
return serialized;
|
|
}
|
|
|
|
Optional<Node> WalkerActor::dom_node_for(WeakPtr<WalkerActor> const& weak_walker, StringView actor)
|
|
{
|
|
if (auto walker = weak_walker.strong_ref())
|
|
return walker->dom_node(actor);
|
|
return {};
|
|
}
|
|
|
|
Optional<Node> WalkerActor::dom_node(StringView actor)
|
|
{
|
|
auto tab = m_tab.strong_ref();
|
|
if (!tab)
|
|
return {};
|
|
|
|
auto maybe_dom_node = m_actor_to_dom_node_map.get(actor);
|
|
if (!maybe_dom_node.has_value() || !maybe_dom_node.value())
|
|
return {};
|
|
|
|
auto const& dom_node = *maybe_dom_node.value();
|
|
auto identifier = NodeIdentifier::for_node(dom_node);
|
|
|
|
return Node { .node = dom_node, .identifier = move(identifier), .tab = tab.release_nonnull() };
|
|
}
|
|
|
|
Optional<JsonObject const&> WalkerActor::find_node_by_selector(JsonObject const& node, StringView selector)
|
|
{
|
|
auto matches = [&](auto const& candidate) {
|
|
return candidate.get_string("name"sv)->equals_ignoring_ascii_case(selector);
|
|
};
|
|
|
|
if (matches(node))
|
|
return node;
|
|
|
|
if (auto children = node.get_array("children"sv); children.has_value()) {
|
|
for (size_t i = 0; i < children->size(); ++i) {
|
|
auto const& child = children->at(i);
|
|
|
|
if (matches(child.as_object()))
|
|
return child.as_object();
|
|
|
|
if (auto result = find_node_by_selector(child.as_object(), selector); result.has_value())
|
|
return result;
|
|
}
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
enum class Direction {
|
|
Previous,
|
|
Next,
|
|
};
|
|
static Optional<JsonObject const&> sibling_for_node(JsonObject const& parent, JsonObject const& node, Direction direction)
|
|
{
|
|
auto children = parent.get_array("children"sv);
|
|
VERIFY(children.has_value());
|
|
|
|
auto index = children->values().find_first_index_if([&](auto const& child) {
|
|
return &child.as_object() == &node;
|
|
});
|
|
VERIFY(index.has_value());
|
|
|
|
switch (direction) {
|
|
case Direction::Previous:
|
|
if (*index == 0)
|
|
return {};
|
|
index = *index - 1;
|
|
break;
|
|
|
|
case Direction::Next:
|
|
if (*index == children->size() - 1)
|
|
return {};
|
|
index = *index + 1;
|
|
break;
|
|
}
|
|
|
|
return children->at(*index).as_object();
|
|
}
|
|
|
|
Optional<JsonObject const&> WalkerActor::previous_sibling_for_node(JsonObject const& node)
|
|
{
|
|
auto parent = m_dom_node_to_parent_map.get(&node);
|
|
if (!parent.has_value() || !parent.value())
|
|
return {};
|
|
return sibling_for_node(*parent.value(), node, Direction::Previous);
|
|
}
|
|
|
|
Optional<JsonObject const&> WalkerActor::next_sibling_for_node(JsonObject const& node)
|
|
{
|
|
auto parent = m_dom_node_to_parent_map.get(&node);
|
|
if (!parent.has_value() || !parent.value())
|
|
return {};
|
|
return sibling_for_node(*parent.value(), node, Direction::Next);
|
|
}
|
|
|
|
Optional<JsonObject const&> WalkerActor::remove_node(JsonObject const& node)
|
|
{
|
|
auto maybe_parent = m_dom_node_to_parent_map.get(&node);
|
|
if (!maybe_parent.has_value() || !maybe_parent.value())
|
|
return {};
|
|
auto const& parent = *maybe_parent.value();
|
|
|
|
auto children = parent.get_array("children"sv);
|
|
VERIFY(children.has_value());
|
|
|
|
const_cast<JsonArray&>(*children).values().remove_first_matching([&](auto const& child) {
|
|
return &child.as_object() == &node;
|
|
});
|
|
|
|
populate_dom_tree_cache();
|
|
return parent;
|
|
}
|
|
|
|
void WalkerActor::new_dom_node_mutation(WebView::Mutation mutation)
|
|
{
|
|
auto serialized_target = JsonValue::from_string(mutation.serialized_target);
|
|
if (serialized_target.is_error() || !serialized_target.value().is_object()) {
|
|
dbgln_if(DEVTOOLS_DEBUG, "Unable to parse serialized target as JSON object: {}", serialized_target.error());
|
|
return;
|
|
}
|
|
|
|
if (!replace_node_in_tree(move(serialized_target.release_value().as_object()))) {
|
|
dbgln_if(DEVTOOLS_DEBUG, "Unable to apply mutation to DOM tree");
|
|
return;
|
|
}
|
|
|
|
m_dom_node_mutations.append(move(mutation));
|
|
|
|
if (m_has_new_mutations_since_last_mutations_request)
|
|
return;
|
|
|
|
JsonObject message;
|
|
message.set("type"sv, "newMutations"sv);
|
|
send_message(move(message));
|
|
|
|
m_has_new_mutations_since_last_mutations_request = true;
|
|
}
|
|
|
|
JsonValue WalkerActor::serialize_mutations()
|
|
{
|
|
JsonArray mutations;
|
|
mutations.ensure_capacity(m_dom_node_mutations.size());
|
|
|
|
for (auto& mutation : m_dom_node_mutations) {
|
|
auto target = m_dom_node_id_to_actor_map.get(mutation.target);
|
|
if (!target.has_value())
|
|
continue;
|
|
|
|
JsonObject serialized;
|
|
serialized.set("target"sv, target.release_value());
|
|
serialized.set("type"sv, move(mutation.type));
|
|
|
|
mutation.mutation.visit(
|
|
[&](WebView::AttributeMutation& mutation) {
|
|
serialized.set("attributeName"sv, move(mutation.attribute_name));
|
|
|
|
if (mutation.new_value.has_value())
|
|
serialized.set("newValue"sv, mutation.new_value.release_value());
|
|
else
|
|
serialized.set("newValue"sv, JsonValue {});
|
|
},
|
|
[&](WebView::CharacterDataMutation& mutation) {
|
|
serialized.set("newValue"sv, move(mutation.new_value));
|
|
},
|
|
[&](WebView::ChildListMutation const& mutation) {
|
|
JsonArray added;
|
|
JsonArray removed;
|
|
|
|
for (auto id : mutation.added) {
|
|
if (auto node = m_dom_node_id_to_actor_map.get(id); node.has_value())
|
|
added.must_append(node.release_value());
|
|
}
|
|
for (auto id : mutation.removed) {
|
|
if (auto node = m_dom_node_id_to_actor_map.get(id); node.has_value())
|
|
removed.must_append(node.release_value());
|
|
}
|
|
|
|
serialized.set("added"sv, move(added));
|
|
serialized.set("removed"sv, move(removed));
|
|
serialized.set("numChildren"sv, mutation.target_child_count);
|
|
});
|
|
|
|
mutations.must_append(move(serialized));
|
|
}
|
|
|
|
m_dom_node_mutations.clear();
|
|
return mutations;
|
|
}
|
|
|
|
bool WalkerActor::replace_node_in_tree(JsonObject replacement)
|
|
{
|
|
auto const& actor = actor_for_node(replacement);
|
|
|
|
auto node = m_actor_to_dom_node_map.get(actor.name());
|
|
if (!node.has_value() || !node.value())
|
|
return false;
|
|
|
|
const_cast<JsonObject&>(*node.value()) = move(replacement);
|
|
populate_dom_tree_cache();
|
|
|
|
return true;
|
|
}
|
|
|
|
void WalkerActor::populate_dom_tree_cache()
|
|
{
|
|
m_dom_node_to_parent_map.clear();
|
|
m_actor_to_dom_node_map.clear();
|
|
m_dom_node_id_to_actor_map.clear();
|
|
|
|
populate_dom_tree_cache(m_dom_tree, nullptr);
|
|
}
|
|
|
|
void WalkerActor::populate_dom_tree_cache(JsonObject& node, JsonObject const* parent)
|
|
{
|
|
auto const& node_actor = actor_for_node(node);
|
|
node.set("actor"sv, node_actor.name());
|
|
|
|
m_dom_node_to_parent_map.set(&node, parent);
|
|
m_actor_to_dom_node_map.set(node_actor.name(), &node);
|
|
|
|
if (!node_actor.node_identifier().pseudo_element.has_value())
|
|
m_dom_node_id_to_actor_map.set(node_actor.node_identifier().id, node_actor.name());
|
|
|
|
auto children = node.get_array("children"sv);
|
|
if (!children.has_value())
|
|
return;
|
|
|
|
children->values().remove_all_matching([&](JsonValue const& child) {
|
|
return !is_suitable_for_dom_inspection(child);
|
|
});
|
|
|
|
children->for_each([&](JsonValue& child) {
|
|
populate_dom_tree_cache(child.as_object(), &node);
|
|
});
|
|
}
|
|
|
|
NodeActor const& WalkerActor::actor_for_node(JsonObject const& node)
|
|
{
|
|
auto identifier = NodeIdentifier::for_node(node);
|
|
|
|
if (auto it = m_node_actors.find(identifier); it != m_node_actors.end()) {
|
|
if (auto node_actor = it->value.strong_ref())
|
|
return *node_actor;
|
|
}
|
|
|
|
auto& node_actor = devtools().register_actor<NodeActor>(identifier, *this);
|
|
m_node_actors.set(identifier, node_actor);
|
|
|
|
return node_actor;
|
|
}
|
|
|
|
}
|