LibDevTools+LibWebView: Port DevTools to String

Author: https://github.com/trflynn89
Commit: https://github.com/LadybirdBrowser/ladybird/commit/4791ec35bf0
Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/3631
Reviewed-by: https://github.com/awesomekling ✅

Libraries/LibDevTools/Actor.cpp

@@ -11,10 +11,9 @@
 
 namespace DevTools {
 
-// FIXME: Convert `name` to a String.
-Actor::Actor(DevToolsServer& devtools, ByteString name)
+Actor::Actor(DevToolsServer& devtools, String name)
     : m_devtools(devtools)
-    , m_name(MUST(String::from_byte_string(name)))
+    , m_name(move(name))
 {
 }
 

Libraries/LibDevTools/Actor.h

@@ -7,7 +7,6 @@
 #pragma once
 
 #include <AK/Badge.h>
-#include <AK/ByteString.h>
 #include <AK/Optional.h>
 #include <AK/RefCounted.h>
 #include <AK/String.h>
@@ -49,7 +48,7 @@ public:
     void send_unknown_actor_error(StringView actor);
 
 protected:
-    explicit Actor(DevToolsServer&, ByteString name);
+    explicit Actor(DevToolsServer&, String name);
 
     DevToolsServer& devtools() { return m_devtools; }
     DevToolsServer const& devtools() const { return m_devtools; }

Libraries/LibDevTools/Actors/CSSPropertiesActor.cpp

@@ -12,12 +12,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<CSSPropertiesActor> CSSPropertiesActor::create(DevToolsServer& devtools, ByteString name)
+NonnullRefPtr<CSSPropertiesActor> CSSPropertiesActor::create(DevToolsServer& devtools, String name)
 {
     return adopt_ref(*new CSSPropertiesActor(devtools, move(name)));
 }
 
-CSSPropertiesActor::CSSPropertiesActor(DevToolsServer& devtools, ByteString name)
+CSSPropertiesActor::CSSPropertiesActor(DevToolsServer& devtools, String name)
     : Actor(devtools, move(name))
 {
 }
@@ -36,7 +36,7 @@ void CSSPropertiesActor::handle_message(StringView type, JsonObject const&)
 
         for (auto const& css_property : css_property_list) {
             JsonArray subproperties;
-            subproperties.must_append(MUST(String::from_byte_string(css_property.name)));
+            subproperties.must_append(css_property.name);
 
             JsonObject property;
             property.set("isInherited"sv, css_property.is_inherited);

Libraries/LibDevTools/Actors/CSSPropertiesActor.h

@@ -6,14 +6,14 @@
 
 #pragma once
 
-#include <AK/ByteString.h>
 #include <AK/NonnullRefPtr.h>
+#include <AK/String.h>
 #include <LibDevTools/Actor.h>
 
 namespace DevTools {
 
 struct CSSProperty {
-    ByteString name;
+    String name;
     bool is_inherited { false };
 };
 
@@ -21,13 +21,13 @@ class CSSPropertiesActor final : public Actor {
 public:
     static constexpr auto base_name = "css-properties"sv;
 
-    static NonnullRefPtr<CSSPropertiesActor> create(DevToolsServer&, ByteString name);
+    static NonnullRefPtr<CSSPropertiesActor> create(DevToolsServer&, String name);
     virtual ~CSSPropertiesActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
 
 private:
-    CSSPropertiesActor(DevToolsServer&, ByteString name);
+    CSSPropertiesActor(DevToolsServer&, String name);
 };
 
 }

Libraries/LibDevTools/Actors/DeviceActor.cpp

@@ -12,12 +12,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<DeviceActor> DeviceActor::create(DevToolsServer& devtools, ByteString name)
+NonnullRefPtr<DeviceActor> DeviceActor::create(DevToolsServer& devtools, String name)
 {
     return adopt_ref(*new DeviceActor(devtools, move(name)));
 }
 
-DeviceActor::DeviceActor(DevToolsServer& devtools, ByteString name)
+DeviceActor::DeviceActor(DevToolsServer& devtools, String name)
     : Actor(devtools, move(name))
 {
 }

Libraries/LibDevTools/Actors/DeviceActor.h

@@ -15,13 +15,13 @@ class DeviceActor final : public Actor {
 public:
     static constexpr auto base_name = "device"sv;
 
-    static NonnullRefPtr<DeviceActor> create(DevToolsServer&, ByteString name);
+    static NonnullRefPtr<DeviceActor> create(DevToolsServer&, String name);
     virtual ~DeviceActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
 
 private:
-    DeviceActor(DevToolsServer&, ByteString name);
+    DeviceActor(DevToolsServer&, String name);
 };
 
 }

Libraries/LibDevTools/Actors/FrameActor.cpp

@@ -14,12 +14,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<FrameActor> FrameActor::create(DevToolsServer& devtools, ByteString name, WeakPtr<TabActor> tab, WeakPtr<CSSPropertiesActor> css_properties, WeakPtr<InspectorActor> inspector, WeakPtr<ThreadActor> thread)
+NonnullRefPtr<FrameActor> FrameActor::create(DevToolsServer& devtools, String name, WeakPtr<TabActor> tab, WeakPtr<CSSPropertiesActor> css_properties, WeakPtr<InspectorActor> inspector, WeakPtr<ThreadActor> thread)
 {
     return adopt_ref(*new FrameActor(devtools, move(name), move(tab), move(css_properties), move(inspector), move(thread)));
 }
 
-FrameActor::FrameActor(DevToolsServer& devtools, ByteString name, WeakPtr<TabActor> tab, WeakPtr<CSSPropertiesActor> css_properties, WeakPtr<InspectorActor> inspector, WeakPtr<ThreadActor> thread)
+FrameActor::FrameActor(DevToolsServer& devtools, String name, WeakPtr<TabActor> tab, WeakPtr<CSSPropertiesActor> css_properties, WeakPtr<InspectorActor> inspector, WeakPtr<ThreadActor> thread)
     : Actor(devtools, move(name))
     , m_tab(move(tab))
     , m_css_properties(move(css_properties))
@@ -50,8 +50,8 @@ void FrameActor::send_frame_update_message()
     if (auto tab_actor = m_tab.strong_ref()) {
         JsonObject frame;
         frame.set("id"sv, tab_actor->description().id);
-        frame.set("title"sv, MUST(String::from_byte_string(tab_actor->description().title)));
-        frame.set("url"sv, MUST(String::from_byte_string(tab_actor->description().url)));
+        frame.set("title"sv, tab_actor->description().title);
+        frame.set("url"sv, tab_actor->description().url);
         frames.must_append(move(frame));
     }
 
@@ -76,8 +76,8 @@ JsonObject FrameActor::serialize_target() const
     target.set("actor"sv, name());
 
     if (auto tab_actor = m_tab.strong_ref()) {
-        target.set("title"sv, MUST(String::from_byte_string(tab_actor->description().title)));
-        target.set("url"sv, MUST(String::from_byte_string(tab_actor->description().url)));
+        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);

Libraries/LibDevTools/Actors/FrameActor.h

@@ -15,7 +15,7 @@ class FrameActor final : public Actor {
 public:
     static constexpr auto base_name = "frame"sv;
 
-    static NonnullRefPtr<FrameActor> create(DevToolsServer&, ByteString name, WeakPtr<TabActor>, WeakPtr<CSSPropertiesActor>, WeakPtr<InspectorActor>, WeakPtr<ThreadActor>);
+    static NonnullRefPtr<FrameActor> create(DevToolsServer&, String name, WeakPtr<TabActor>, WeakPtr<CSSPropertiesActor>, WeakPtr<InspectorActor>, WeakPtr<ThreadActor>);
     virtual ~FrameActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
@@ -24,7 +24,7 @@ public:
     JsonObject serialize_target() const;
 
 private:
-    FrameActor(DevToolsServer&, ByteString name, WeakPtr<TabActor>, WeakPtr<CSSPropertiesActor>, WeakPtr<InspectorActor>, WeakPtr<ThreadActor>);
+    FrameActor(DevToolsServer&, String name, WeakPtr<TabActor>, WeakPtr<CSSPropertiesActor>, WeakPtr<InspectorActor>, WeakPtr<ThreadActor>);
 
     WeakPtr<TabActor> m_tab;
 

Libraries/LibDevTools/Actors/HighlighterActor.cpp

@@ -9,12 +9,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<HighlighterActor> HighlighterActor::create(DevToolsServer& devtools, ByteString name)
+NonnullRefPtr<HighlighterActor> HighlighterActor::create(DevToolsServer& devtools, String name)
 {
     return adopt_ref(*new HighlighterActor(devtools, move(name)));
 }
 
-HighlighterActor::HighlighterActor(DevToolsServer& devtools, ByteString name)
+HighlighterActor::HighlighterActor(DevToolsServer& devtools, String name)
     : Actor(devtools, move(name))
 {
 }

Libraries/LibDevTools/Actors/HighlighterActor.h

@@ -15,14 +15,14 @@ class HighlighterActor final : public Actor {
 public:
     static constexpr auto base_name = "highlighter"sv;
 
-    static NonnullRefPtr<HighlighterActor> create(DevToolsServer&, ByteString name);
+    static NonnullRefPtr<HighlighterActor> create(DevToolsServer&, String name);
     virtual ~HighlighterActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
     JsonValue serialize_highlighter() const;
 
 private:
-    HighlighterActor(DevToolsServer&, ByteString name);
+    HighlighterActor(DevToolsServer&, String name);
 };
 
 }

Libraries/LibDevTools/Actors/InspectorActor.cpp

@@ -16,12 +16,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<InspectorActor> InspectorActor::create(DevToolsServer& devtools, ByteString name, WeakPtr<TabActor> tab)
+NonnullRefPtr<InspectorActor> InspectorActor::create(DevToolsServer& devtools, String name, WeakPtr<TabActor> tab)
 {
     return adopt_ref(*new InspectorActor(devtools, move(name), move(tab)));
 }
 
-InspectorActor::InspectorActor(DevToolsServer& devtools, ByteString name, WeakPtr<TabActor> tab)
+InspectorActor::InspectorActor(DevToolsServer& devtools, String name, WeakPtr<TabActor> tab)
     : Actor(devtools, move(name))
     , m_tab(move(tab))
 {

Libraries/LibDevTools/Actors/InspectorActor.h

@@ -15,13 +15,13 @@ class InspectorActor final : public Actor {
 public:
     static constexpr auto base_name = "inspector"sv;
 
-    static NonnullRefPtr<InspectorActor> create(DevToolsServer&, ByteString name, WeakPtr<TabActor>);
+    static NonnullRefPtr<InspectorActor> create(DevToolsServer&, String name, WeakPtr<TabActor>);
     virtual ~InspectorActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
 
 private:
-    InspectorActor(DevToolsServer&, ByteString name, WeakPtr<TabActor>);
+    InspectorActor(DevToolsServer&, String name, WeakPtr<TabActor>);
 
     void received_dom_tree(JsonObject, BlockToken);
 

Libraries/LibDevTools/Actors/PageStyleActor.cpp

@@ -9,12 +9,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<PageStyleActor> PageStyleActor::create(DevToolsServer& devtools, ByteString name)
+NonnullRefPtr<PageStyleActor> PageStyleActor::create(DevToolsServer& devtools, String name)
 {
     return adopt_ref(*new PageStyleActor(devtools, move(name)));
 }
 
-PageStyleActor::PageStyleActor(DevToolsServer& devtools, ByteString name)
+PageStyleActor::PageStyleActor(DevToolsServer& devtools, String name)
     : Actor(devtools, move(name))
 {
 }

Libraries/LibDevTools/Actors/PageStyleActor.h

@@ -15,14 +15,14 @@ class PageStyleActor final : public Actor {
 public:
     static constexpr auto base_name = "page-style"sv;
 
-    static NonnullRefPtr<PageStyleActor> create(DevToolsServer&, ByteString name);
+    static NonnullRefPtr<PageStyleActor> create(DevToolsServer&, String name);
     virtual ~PageStyleActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
     JsonValue serialize_style() const;
 
 private:
-    PageStyleActor(DevToolsServer&, ByteString name);
+    PageStyleActor(DevToolsServer&, String name);
 };
 
 }

Libraries/LibDevTools/Actors/PreferenceActor.cpp

@@ -9,12 +9,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<PreferenceActor> PreferenceActor::create(DevToolsServer& devtools, ByteString name)
+NonnullRefPtr<PreferenceActor> PreferenceActor::create(DevToolsServer& devtools, String name)
 {
     return adopt_ref(*new PreferenceActor(devtools, move(name)));
 }
 
-PreferenceActor::PreferenceActor(DevToolsServer& devtools, ByteString name)
+PreferenceActor::PreferenceActor(DevToolsServer& devtools, String name)
     : Actor(devtools, move(name))
 {
 }

Libraries/LibDevTools/Actors/PreferenceActor.h

@@ -15,13 +15,13 @@ class PreferenceActor final : public Actor {
 public:
     static constexpr auto base_name = "preference"sv;
 
-    static NonnullRefPtr<PreferenceActor> create(DevToolsServer&, ByteString name);
+    static NonnullRefPtr<PreferenceActor> create(DevToolsServer&, String name);
     virtual ~PreferenceActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
 
 private:
-    PreferenceActor(DevToolsServer&, ByteString name);
+    PreferenceActor(DevToolsServer&, String name);
 };
 
 }

Libraries/LibDevTools/Actors/ProcessActor.cpp

@@ -9,12 +9,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<ProcessActor> ProcessActor::create(DevToolsServer& devtools, ByteString name, ProcessDescription description)
+NonnullRefPtr<ProcessActor> ProcessActor::create(DevToolsServer& devtools, String name, ProcessDescription description)
 {
     return adopt_ref(*new ProcessActor(devtools, move(name), move(description)));
 }
 
-ProcessActor::ProcessActor(DevToolsServer& devtools, ByteString name, ProcessDescription description)
+ProcessActor::ProcessActor(DevToolsServer& devtools, String name, ProcessDescription description)
     : Actor(devtools, move(name))
     , m_description(move(description))
 {

Libraries/LibDevTools/Actors/ProcessActor.h

@@ -21,7 +21,7 @@ class ProcessActor final : public Actor {
 public:
     static constexpr auto base_name = "process"sv;
 
-    static NonnullRefPtr<ProcessActor> create(DevToolsServer&, ByteString name, ProcessDescription);
+    static NonnullRefPtr<ProcessActor> create(DevToolsServer&, String name, ProcessDescription);
     virtual ~ProcessActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
@@ -30,7 +30,7 @@ public:
     JsonObject serialize_description() const;
 
 private:
-    ProcessActor(DevToolsServer&, ByteString name, ProcessDescription);
+    ProcessActor(DevToolsServer&, String name, ProcessDescription);
 
     ProcessDescription m_description;
 };

Libraries/LibDevTools/Actors/RootActor.cpp

@@ -16,7 +16,7 @@
 namespace DevTools {
 
 // https://firefox-source-docs.mozilla.org/devtools/backend/protocol.html#the-root-actor
-NonnullRefPtr<RootActor> RootActor::create(DevToolsServer& devtools, ByteString name)
+NonnullRefPtr<RootActor> RootActor::create(DevToolsServer& devtools, String name)
 {
     auto actor = adopt_ref(*new RootActor(devtools, move(name)));
 
@@ -35,7 +35,7 @@ NonnullRefPtr<RootActor> RootActor::create(DevToolsServer& devtools, ByteString
     return actor;
 }
 
-RootActor::RootActor(DevToolsServer& devtools, ByteString name)
+RootActor::RootActor(DevToolsServer& devtools, String name)
     : Actor(devtools, move(name))
 {
 }
@@ -57,9 +57,9 @@ void RootActor::handle_message(StringView type, JsonObject const& message)
 
         for (auto const& actor : devtools().actor_registry()) {
             if (is<DeviceActor>(*actor.value))
-                response.set("deviceActor"sv, MUST(String::from_byte_string(actor.key)));
+                response.set("deviceActor"sv, actor.key);
             else if (is<PreferenceActor>(*actor.value))
-                response.set("preferenceActor"sv, MUST(String::from_byte_string(actor.key)));
+                response.set("preferenceActor"sv, actor.key);
         }
 
         send_message(move(response));

Libraries/LibDevTools/Actors/RootActor.h

@@ -15,7 +15,7 @@ class RootActor final : public Actor {
 public:
     static constexpr auto base_name = "root"sv;
 
-    static NonnullRefPtr<RootActor> create(DevToolsServer&, ByteString name);
+    static NonnullRefPtr<RootActor> create(DevToolsServer&, String name);
     virtual ~RootActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
@@ -23,7 +23,7 @@ public:
     void send_tab_list_changed_message();
 
 private:
-    RootActor(DevToolsServer&, ByteString name);
+    RootActor(DevToolsServer&, String name);
 
     // https://firefox-source-docs.mozilla.org/devtools/backend/protocol.html#the-request-reply-notify-pattern
     // the root actor sends at most one "tabListChanged" notification after each "listTabs" request.

Libraries/LibDevTools/Actors/TabActor.cpp

@@ -11,12 +11,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<TabActor> TabActor::create(DevToolsServer& devtools, ByteString name, TabDescription description)
+NonnullRefPtr<TabActor> TabActor::create(DevToolsServer& devtools, String name, TabDescription description)
 {
     return adopt_ref(*new TabActor(devtools, move(name), move(description)));
 }
 
-TabActor::TabActor(DevToolsServer& devtools, ByteString name, TabDescription description)
+TabActor::TabActor(DevToolsServer& devtools, String name, TabDescription description)
     : Actor(devtools, move(name))
     , m_description(move(description))
 {
@@ -60,8 +60,8 @@ JsonObject TabActor::serialize_description() const
     //        provide different IDs for browserId, browsingContextID, and outerWindowID.
     JsonObject description;
     description.set("actor"sv, name());
-    description.set("title"sv, MUST(String::from_byte_string(m_description.title)));
-    description.set("url"sv, MUST(String::from_byte_string(m_description.url)));
+    description.set("title"sv, m_description.title);
+    description.set("url"sv, m_description.url);
     description.set("browserId"sv, m_description.id);
     description.set("browsingContextID"sv, m_description.id);
     description.set("outerWindowID"sv, m_description.id);

Libraries/LibDevTools/Actors/TabActor.h

@@ -7,21 +7,22 @@
 #pragma once
 
 #include <AK/NonnullRefPtr.h>
+#include <AK/String.h>
 #include <LibDevTools/Actor.h>
 
 namespace DevTools {
 
 struct TabDescription {
     u64 id { 0 };
-    ByteString title;
-    ByteString url;
+    String title;
+    String url;
 };
 
 class TabActor final : public Actor {
 public:
     static constexpr auto base_name = "tab"sv;
 
-    static NonnullRefPtr<TabActor> create(DevToolsServer&, ByteString name, TabDescription);
+    static NonnullRefPtr<TabActor> create(DevToolsServer&, String name, TabDescription);
     virtual ~TabActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
@@ -30,7 +31,7 @@ public:
     JsonObject serialize_description() const;
 
 private:
-    TabActor(DevToolsServer&, ByteString name, TabDescription);
+    TabActor(DevToolsServer&, String name, TabDescription);
 
     TabDescription m_description;
     WeakPtr<WatcherActor> m_watcher;

Libraries/LibDevTools/Actors/TargetConfigurationActor.cpp

@@ -10,12 +10,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<TargetConfigurationActor> TargetConfigurationActor::create(DevToolsServer& devtools, ByteString name)
+NonnullRefPtr<TargetConfigurationActor> TargetConfigurationActor::create(DevToolsServer& devtools, String name)
 {
     return adopt_ref(*new TargetConfigurationActor(devtools, move(name)));
 }
 
-TargetConfigurationActor::TargetConfigurationActor(DevToolsServer& devtools, ByteString name)
+TargetConfigurationActor::TargetConfigurationActor(DevToolsServer& devtools, String name)
     : Actor(devtools, move(name))
 {
 }

Libraries/LibDevTools/Actors/TargetConfigurationActor.h

@@ -15,7 +15,7 @@ class TargetConfigurationActor final : public Actor {
 public:
     static constexpr auto base_name = "target-configuration"sv;
 
-    static NonnullRefPtr<TargetConfigurationActor> create(DevToolsServer&, ByteString name);
+    static NonnullRefPtr<TargetConfigurationActor> create(DevToolsServer&, String name);
     virtual ~TargetConfigurationActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
@@ -23,7 +23,7 @@ public:
     JsonObject serialize_configuration() const;
 
 private:
-    TargetConfigurationActor(DevToolsServer&, ByteString name);
+    TargetConfigurationActor(DevToolsServer&, String name);
 };
 
 }

Libraries/LibDevTools/Actors/ThreadActor.cpp

@@ -8,12 +8,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<ThreadActor> ThreadActor::create(DevToolsServer& devtools, ByteString name)
+NonnullRefPtr<ThreadActor> ThreadActor::create(DevToolsServer& devtools, String name)
 {
     return adopt_ref(*new ThreadActor(devtools, move(name)));
 }
 
-ThreadActor::ThreadActor(DevToolsServer& devtools, ByteString name)
+ThreadActor::ThreadActor(DevToolsServer& devtools, String name)
     : Actor(devtools, move(name))
 {
 }

Libraries/LibDevTools/Actors/ThreadActor.h

@@ -15,13 +15,13 @@ class ThreadActor final : public Actor {
 public:
     static constexpr auto base_name = "thread"sv;
 
-    static NonnullRefPtr<ThreadActor> create(DevToolsServer&, ByteString name);
+    static NonnullRefPtr<ThreadActor> create(DevToolsServer&, String name);
     virtual ~ThreadActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
 
 private:
-    ThreadActor(DevToolsServer&, ByteString name);
+    ThreadActor(DevToolsServer&, String name);
 };
 
 }

Libraries/LibDevTools/Actors/ThreadConfigurationActor.cpp

@@ -10,12 +10,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<ThreadConfigurationActor> ThreadConfigurationActor::create(DevToolsServer& devtools, ByteString name)
+NonnullRefPtr<ThreadConfigurationActor> ThreadConfigurationActor::create(DevToolsServer& devtools, String name)
 {
     return adopt_ref(*new ThreadConfigurationActor(devtools, move(name)));
 }
 
-ThreadConfigurationActor::ThreadConfigurationActor(DevToolsServer& devtools, ByteString name)
+ThreadConfigurationActor::ThreadConfigurationActor(DevToolsServer& devtools, String name)
     : Actor(devtools, move(name))
 {
 }

Libraries/LibDevTools/Actors/ThreadConfigurationActor.h

@@ -15,7 +15,7 @@ class ThreadConfigurationActor final : public Actor {
 public:
     static constexpr auto base_name = "thread-configuration"sv;
 
-    static NonnullRefPtr<ThreadConfigurationActor> create(DevToolsServer&, ByteString name);
+    static NonnullRefPtr<ThreadConfigurationActor> create(DevToolsServer&, String name);
     virtual ~ThreadConfigurationActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
@@ -23,7 +23,7 @@ public:
     JsonObject serialize_configuration() const;
 
 private:
-    ThreadConfigurationActor(DevToolsServer&, ByteString name);
+    ThreadConfigurationActor(DevToolsServer&, String name);
 };
 
 }

Libraries/LibDevTools/Actors/WalkerActor.cpp

@@ -5,18 +5,19 @@
  */
 
 #include <AK/JsonArray.h>
+#include <AK/StringUtils.h>
 #include <LibDevTools/Actors/TabActor.h>
 #include <LibDevTools/Actors/WalkerActor.h>
 #include <LibWeb/DOM/NodeType.h>
 
 namespace DevTools {
 
-NonnullRefPtr<WalkerActor> WalkerActor::create(DevToolsServer& devtools, ByteString name, WeakPtr<TabActor> tab, JsonObject dom_tree)
+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, ByteString name, WeakPtr<TabActor> tab, JsonObject 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))
@@ -32,7 +33,7 @@ void WalkerActor::handle_message(StringView type, JsonObject const& message)
     response.set("from"sv, name());
 
     if (type == "children"sv) {
-        auto node = message.get_byte_string("node"sv);
+        auto node = message.get_string("node"sv);
         if (!node.has_value()) {
             send_missing_parameter_error("node"sv);
             return;
@@ -57,13 +58,13 @@ void WalkerActor::handle_message(StringView type, JsonObject const& message)
     }
 
     if (type == "querySelector"sv) {
-        auto node = message.get_byte_string("node"sv);
+        auto node = message.get_string("node"sv);
         if (!node.has_value()) {
             send_missing_parameter_error("node"sv);
             return;
         }
 
-        auto selector = message.get_byte_string("selector"sv);
+        auto selector = message.get_string("selector"sv);
         if (!selector.has_value()) {
             send_missing_parameter_error("selector"sv);
             return;
@@ -112,12 +113,12 @@ bool WalkerActor::is_suitable_for_dom_inspection(JsonValue const& node)
     if (!object.has_string("name"sv) || !object.has_string("type"sv))
         return false;
 
-    if (auto text = object.get_byte_string("text"sv); text.has_value()) {
-        if (text->is_whitespace())
+    if (auto text = object.get_string("text"sv); text.has_value()) {
+        if (AK::StringUtils::is_whitespace(*text))
             return false;
     }
-    if (auto data = object.get_byte_string("data"sv); data.has_value()) {
-        if (data->is_whitespace())
+    if (auto data = object.get_string("data"sv); data.has_value()) {
+        if (AK::StringUtils::is_whitespace(*data))
             return false;
     }
 
@@ -189,7 +190,7 @@ JsonValue WalkerActor::serialize_node(JsonObject const& node) const
     JsonObject serialized;
     serialized.set("actor"sv, actor.release_value());
     serialized.set("attrs"sv, move(attrs));
-    serialized.set("baseURI"sv, MUST(String::from_byte_string(tab->description().url)));
+    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());
@@ -230,7 +231,7 @@ JsonValue WalkerActor::serialize_node(JsonObject const& node) const
 Optional<JsonObject const&> WalkerActor::find_node_by_selector(JsonObject const& node, StringView selector)
 {
     auto matches = [&](auto const& candidate) {
-        return candidate.get_byte_string("name"sv)->equals_ignoring_ascii_case(selector);
+        return candidate.get_string("name"sv)->equals_ignoring_ascii_case(selector);
     };
 
     if (matches(node))
@@ -256,7 +257,7 @@ void WalkerActor::populate_dom_tree_cache(JsonObject& node, JsonObject const* pa
     m_dom_node_to_parent_map.set(&node, parent);
 
     auto actor = MUST(String::formatted("{}-node{}", name(), m_dom_node_count++));
-    m_actor_to_dom_node_map.set(actor.to_byte_string(), &node);
+    m_actor_to_dom_node_map.set(actor, &node);
     node.set("actor"sv, actor);
 
     auto children = node.get_array("children"sv);

Libraries/LibDevTools/Actors/WalkerActor.h

@@ -18,7 +18,7 @@ class WalkerActor final : public Actor {
 public:
     static constexpr auto base_name = "walker"sv;
 
-    static NonnullRefPtr<WalkerActor> create(DevToolsServer&, ByteString name, WeakPtr<TabActor>, JsonObject dom_tree);
+    static NonnullRefPtr<WalkerActor> create(DevToolsServer&, String name, WeakPtr<TabActor>, JsonObject dom_tree);
     virtual ~WalkerActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
@@ -27,7 +27,7 @@ public:
     JsonValue serialize_root() const;
 
 private:
-    WalkerActor(DevToolsServer&, ByteString name, WeakPtr<TabActor>, JsonObject dom_tree);
+    WalkerActor(DevToolsServer&, String name, WeakPtr<TabActor>, JsonObject dom_tree);
 
     JsonValue serialize_node(JsonObject const&) const;
     Optional<JsonObject const&> find_node_by_selector(JsonObject const& node, StringView selector);
@@ -38,7 +38,7 @@ private:
     JsonObject m_dom_tree;
 
     HashMap<JsonObject const*, JsonObject const*> m_dom_node_to_parent_map;
-    HashMap<ByteString, JsonObject const*> m_actor_to_dom_node_map;
+    HashMap<String, JsonObject const*> m_actor_to_dom_node_map;
     size_t m_dom_node_count { 0 };
 };
 

Libraries/LibDevTools/Actors/WatcherActor.cpp

@@ -18,12 +18,12 @@
 
 namespace DevTools {
 
-NonnullRefPtr<WatcherActor> WatcherActor::create(DevToolsServer& devtools, ByteString name, WeakPtr<TabActor> tab)
+NonnullRefPtr<WatcherActor> WatcherActor::create(DevToolsServer& devtools, String name, WeakPtr<TabActor> tab)
 {
     return adopt_ref(*new WatcherActor(devtools, move(name), move(tab)));
 }
 
-WatcherActor::WatcherActor(DevToolsServer& devtools, ByteString name, WeakPtr<TabActor> tab)
+WatcherActor::WatcherActor(DevToolsServer& devtools, String name, WeakPtr<TabActor> tab)
     : Actor(devtools, move(name))
     , m_tab(move(tab))
 {
@@ -67,7 +67,7 @@ void WatcherActor::handle_message(StringView type, JsonObject const& message)
     }
 
     if (type == "watchTargets"sv) {
-        auto target_type = message.get_byte_string("targetType"sv);
+        auto target_type = message.get_string("targetType"sv);
         if (!target_type.has_value()) {
             send_missing_parameter_error("targetType"sv);
             return;

Libraries/LibDevTools/Actors/WatcherActor.h

@@ -15,7 +15,7 @@ class WatcherActor final : public Actor {
 public:
     static constexpr auto base_name = "watcher"sv;
 
-    static NonnullRefPtr<WatcherActor> create(DevToolsServer&, ByteString name, WeakPtr<TabActor>);
+    static NonnullRefPtr<WatcherActor> create(DevToolsServer&, String name, WeakPtr<TabActor>);
     virtual ~WatcherActor() override;
 
     virtual void handle_message(StringView type, JsonObject const&) override;
@@ -23,7 +23,7 @@ public:
     JsonObject serialize_description() const;
 
 private:
-    WatcherActor(DevToolsServer&, ByteString name, WeakPtr<TabActor>);
+    WatcherActor(DevToolsServer&, String name, WeakPtr<TabActor>);
 
     WeakPtr<TabActor> m_tab;
     WeakPtr<Actor> m_target;

Libraries/LibDevTools/DevToolsServer.cpp

@@ -85,7 +85,7 @@ ErrorOr<void> DevToolsServer::on_new_client()
 
 void DevToolsServer::on_message_received(JsonObject const& message)
 {
-    auto to = message.get_byte_string("to"sv);
+    auto to = message.get_string("to"sv);
     if (!to.has_value()) {
         m_root_actor->send_missing_parameter_error("to"sv);
         return;
@@ -97,7 +97,7 @@ void DevToolsServer::on_message_received(JsonObject const& message)
         return;
     }
 
-    auto type = message.get_byte_string("type"sv);
+    auto type = message.get_string("type"sv);
     if (!type.has_value()) {
         actor->value->send_missing_parameter_error("type"sv);
         return;

Libraries/LibDevTools/DevToolsServer.h

@@ -10,13 +10,14 @@
 #include <AK/HashMap.h>
 #include <AK/NonnullOwnPtr.h>
 #include <AK/NonnullRefPtr.h>
+#include <AK/String.h>
 #include <LibCore/Socket.h>
 #include <LibDevTools/Actors/RootActor.h>
 #include <LibDevTools/Forward.h>
 
 namespace DevTools {
 
-using ActorRegistry = HashMap<ByteString, NonnullRefPtr<Actor>>;
+using ActorRegistry = HashMap<String, NonnullRefPtr<Actor>>;
 
 class DevToolsServer {
 public:
@@ -30,12 +31,12 @@ public:
     template<typename ActorType, typename... Args>
     ActorType& register_actor(Args&&... args)
     {
-        ByteString name;
+        String name;
 
         if constexpr (IsSame<ActorType, RootActor>) {
-            name = ActorType::base_name;
+            name = String::from_utf8_without_validation(ActorType::base_name.bytes());
         } else {
-            name = ByteString::formatted("server{}-{}{}", m_server_id, ActorType::base_name, m_actor_count);
+            name = MUST(String::formatted("server{}-{}{}", m_server_id, ActorType::base_name, m_actor_count));
         }
 
         auto actor = ActorType::create(*this, name, forward<Args>(args)...);

Libraries/LibWebView/Application.cpp

@@ -340,7 +340,7 @@ Vector<DevTools::TabDescription> Application::tab_list() const
     Vector<DevTools::TabDescription> tabs;
 
     ViewImplementation::for_each_view([&](ViewImplementation& view) {
-        tabs.empend(view.view_id(), view.title(), view.url().to_byte_string());
+        tabs.empend(view.view_id(), MUST(String::from_byte_string(view.title())), view.url().to_string());
         return IterationDecision::Continue;
     });
 
@@ -355,7 +355,7 @@ Vector<DevTools::CSSProperty> Application::css_property_list() const
         auto property_id = static_cast<Web::CSS::PropertyID>(i);
 
         DevTools::CSSProperty property;
-        property.name = Web::CSS::string_from_property_id(property_id).to_string().to_byte_string();
+        property.name = Web::CSS::string_from_property_id(property_id).to_string();
         property.is_inherited = Web::CSS::is_inherited_property(property_id);
         property_list.append(move(property));
     }