mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-07-30 04:39:06 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

LibGC+Everywhere: Factor out a LibGC from LibJS

Browse source 
Resulting in a massive rename across almost everywhere! Alongside the
namespace change, we now have the following names:

 * JS::NonnullGCPtr -> GC::Ref
 * JS::GCPtr -> GC::Ptr
 * JS::HeapFunction -> GC::Function
 * JS::CellImpl -> GC::Cell
 * JS::Handle -> GC::Root
This commit is contained in:
Shannon Booth 2024-11-15 04:01:23 +13:00 • committed by Andreas Kling
commit f87041bf3a
Notes: github-actions[bot] 2024-11-15 13:50:17 +00:00
1722 changed files with 9939 additions and 9906 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Libraries/LibWeb/Loader/LoadRequest.h
View file

@ -43,7 +43,7 @@ public:
void start_timer() { m_load_timer.start(); }
AK::Duration load_time() const { return m_load_timer.elapsed_time(); }
JS::GCPtr<Page> page() const { return m_page.ptr(); }
GC::Ptr<Page> page() const { return m_page.ptr(); }
void set_page(Page& page) { m_page = page; }
unsigned hash() const
@ -80,7 +80,7 @@ private:
HashMap<ByteString, ByteString, CaseInsensitiveStringTraits> m_headers;
ByteBuffer m_body;
Core::ElapsedTimer m_load_timer;
JS::Handle<Page> m_page;
GC::Root<Page> m_page;
bool m_main_resource { false };
};

2
Libraries/LibWeb/Loader/Resource.cpp
View file

@ -159,7 +159,7 @@ void ResourceClient::set_resource(Resource* resource)
// This ensures that these callbacks always happen in a consistent way, instead of being invoked
// synchronously in some cases, and asynchronously in others.
if (resource->is_loaded() || resource->is_failed()) {
Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(ResourceLoader::the().heap(), [weak_this = make_weak_ptr(), strong_resource = NonnullRefPtr { *m_resource }] {
Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(ResourceLoader::the().heap(), [weak_this = make_weak_ptr(), strong_resource = NonnullRefPtr { *m_resource }] {
if (!weak_this)
return;

20
Libraries/LibWeb/Loader/ResourceLoader.cpp
View file

@ -30,7 +30,7 @@ namespace Web {
static RefPtr<ResourceLoader> s_resource_loader;
void ResourceLoader::initialize(JS::Heap& heap, NonnullRefPtr<Requests::RequestClient> request_client)
void ResourceLoader::initialize(GC::Heap& heap, NonnullRefPtr<Requests::RequestClient> request_client)
{
s_resource_loader = adopt_ref(*new ResourceLoader(heap, move(request_client)));
}
@ -44,7 +44,7 @@ ResourceLoader& ResourceLoader::the()
return *s_resource_loader;
}
ResourceLoader::ResourceLoader(JS::Heap& heap, NonnullRefPtr<Requests::RequestClient> request_client)
ResourceLoader::ResourceLoader(GC::Heap& heap, NonnullRefPtr<Requests::RequestClient> request_client)
: m_heap(heap)
, m_request_client(move(request_client))
, m_user_agent(MUST(String::from_utf8(default_user_agent)))
@ -108,10 +108,10 @@ RefPtr<Resource> ResourceLoader::load_resource(Resource::Type type, LoadRequest&
load(
request,
JS::create_heap_function(m_heap, [=](ReadonlyBytes data, HTTP::HeaderMap const& headers, Optional<u32> status_code, Optional<String> const&) {
GC::create_function(m_heap, [=](ReadonlyBytes data, HTTP::HeaderMap const& headers, Optional<u32> status_code, Optional<String> const&) {
const_cast<Resource&>(*resource).did_load({}, data, headers, status_code);
}),
JS::create_heap_function(m_heap, [=](ByteString const& error, Optional<u32> status_code, Optional<String> const&, ReadonlyBytes data, HTTP::HeaderMap const& headers) {
GC::create_function(m_heap, [=](ByteString const& error, Optional<u32> status_code, Optional<String> const&, ReadonlyBytes data, HTTP::HeaderMap const& headers) {
const_cast<Resource&>(*resource).did_fail({}, error, data, headers, status_code);
}));
@ -230,7 +230,7 @@ static bool should_block_request(LoadRequest const& request)
return false;
}
void ResourceLoader::load(LoadRequest& request, JS::Handle<SuccessCallback> success_callback, JS::Handle<ErrorCallback> error_callback, Optional<u32> timeout, JS::Handle<TimeoutCallback> timeout_callback)
void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> success_callback, GC::Root<ErrorCallback> error_callback, Optional<u32> timeout, GC::Root<TimeoutCallback> timeout_callback)
{
auto const& url = request.url();
@ -242,7 +242,7 @@ void ResourceLoader::load(LoadRequest& request, JS::Handle<SuccessCallback> succ
return;
}
auto respond_directory_page = [](LoadRequest const& request, URL::URL const& url, JS::Handle<SuccessCallback> success_callback, JS::Handle<ErrorCallback> error_callback) {
auto respond_directory_page = [](LoadRequest const& request, URL::URL const& url, GC::Root<SuccessCallback> success_callback, GC::Root<ErrorCallback> error_callback) {
auto maybe_response = load_file_directory_page(url);
if (maybe_response.is_error()) {
log_failure(request, maybe_response.error());
@ -278,7 +278,7 @@ void ResourceLoader::load(LoadRequest& request, JS::Handle<SuccessCallback> succ
return;
}
Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_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)] {
success_callback->function()(ByteString::empty().to_byte_buffer(), response_headers, {}, {});
}));
return;
@ -303,7 +303,7 @@ void ResourceLoader::load(LoadRequest& request, JS::Handle<SuccessCallback> succ
log_success(request);
Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(m_heap, [data = move(data_url.body), response_headers = move(response_headers), success_callback] {
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, {}, {});
}));
return;
@ -415,7 +415,7 @@ void ResourceLoader::load(LoadRequest& request, JS::Handle<SuccessCallback> succ
if (timeout.has_value() && timeout.value() > 0) {
auto timer = Platform::Timer::create_single_shot(m_heap, timeout.value(), nullptr);
timer->on_timeout = JS::create_heap_function(m_heap, [timer = JS::make_handle(timer), protocol_request, timeout_callback] {
timer->on_timeout = GC::create_function(m_heap, [timer = GC::make_root(timer), protocol_request, timeout_callback] {
(void)timer;
protocol_request->stop();
if (timeout_callback)
@ -465,7 +465,7 @@ void ResourceLoader::load(LoadRequest& request, JS::Handle<SuccessCallback> succ
error_callback->function()(not_implemented_error, {}, {}, {}, {});
}
void ResourceLoader::load_unbuffered(LoadRequest& request, JS::Handle<OnHeadersReceived> on_headers_received, JS::Handle<OnDataReceived> on_data_received, JS::Handle<OnComplete> on_complete)
void ResourceLoader::load_unbuffered(LoadRequest& request, GC::Root<OnHeadersReceived> on_headers_received, GC::Root<OnDataReceived> on_data_received, GC::Root<OnComplete> on_complete)
{
auto const& url = request.url();

26
Libraries/LibWeb/Loader/ResourceLoader.h
View file

@ -21,22 +21,22 @@ namespace Web {
class ResourceLoader : public Core::EventReceiver {
C_OBJECT_ABSTRACT(ResourceLoader)
public:
static void initialize(JS::Heap&, NonnullRefPtr<Requests::RequestClient>);
static void initialize(GC::Heap&, NonnullRefPtr<Requests::RequestClient>);
static ResourceLoader& the();
RefPtr<Resource> load_resource(Resource::Type, LoadRequest&);
using SuccessCallback = JS::HeapFunction<void(ReadonlyBytes, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase)>;
using ErrorCallback = JS::HeapFunction<void(ByteString const&, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes payload, HTTP::HeaderMap const& response_headers)>;
using TimeoutCallback = JS::HeapFunction<void()>;
using SuccessCallback = GC::Function<void(ReadonlyBytes, 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 TimeoutCallback = GC::Function<void()>;
void load(LoadRequest&, JS::Handle<SuccessCallback> success_callback, JS::Handle<ErrorCallback> error_callback = nullptr, Optional<u32> timeout = {}, JS::Handle<TimeoutCallback> timeout_callback = nullptr);
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 = JS::HeapFunction<void(HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase)>;
using OnDataReceived = JS::HeapFunction<void(ReadonlyBytes data)>;
using OnComplete = JS::HeapFunction<void(bool success, Optional<StringView> error_message)>;
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)>;
void load_unbuffered(LoadRequest&, JS::Handle<OnHeadersReceived>, JS::Handle<OnDataReceived>, JS::Handle<OnComplete>);
void load_unbuffered(LoadRequest&, GC::Root<OnHeadersReceived>, GC::Root<OnDataReceived>, GC::Root<OnComplete>);
Requests::RequestClient& request_client() { return *m_request_client; }
@ -73,10 +73,10 @@ public:
void clear_cache();
void evict_from_cache(LoadRequest const&);
JS::Heap& heap() { return m_heap; }
GC::Heap& heap() { return m_heap; }
private:
explicit ResourceLoader(JS::Heap&, NonnullRefPtr<Requests::RequestClient>);
explicit ResourceLoader(GC::Heap&, NonnullRefPtr<Requests::RequestClient>);
RefPtr<Requests::Request> start_network_request(LoadRequest const&);
void handle_network_response_headers(LoadRequest const&, HTTP::HeaderMap const&);
@ -84,7 +84,7 @@ private:
int m_pending_loads { 0 };
JS::Heap& m_heap;
GC::Heap& m_heap;
NonnullRefPtr<Requests::RequestClient> m_request_client;
HashTable<NonnullRefPtr<Requests::Request>> m_active_requests;
@ -93,7 +93,7 @@ private:
Vector<String> m_preferred_languages = { "en"_string };
NavigatorCompatibilityMode m_navigator_compatibility_mode;
bool m_enable_do_not_track { false };
Optional<JS::GCPtr<Page>> m_page {};
Optional<GC::Ptr<Page>> m_page {};
};
}