LibWeb: Delete unused ResourceLoader::load()

...and rename `load_unbuffered()` to `load()`.

Author: kalenikaliaksandr

Libraries/LibWeb/Fetch/Fetching/Fetching.cpp

@@ -2435,7 +2435,7 @@ GC::Ref<PendingResponse> nonstandard_resource_loader_file_or_http_network_fetch(
         }
     });
 
-    ResourceLoader::the().load_unbuffered(load_request, on_headers_received, on_data_received, on_complete);
+    ResourceLoader::the().load(load_request, on_headers_received, on_data_received, on_complete);
 
     return pending_response;
 }

Libraries/LibWeb/Loader/ResourceLoader.cpp

@@ -345,151 +345,7 @@ void ResourceLoader::handle_resource_load_request(LoadRequest const& request, Re
     on_resource(load_result);
 }
 
-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().value();
-
-    log_request_start(request);
-    request.start_timer();
-
-    if (should_block_request(request)) {
-        error_callback->function()("Request was blocked", {}, {}, {}, {}, {});
-        return;
-    }
-
-    if (url.scheme() == "about") {
-        handle_about_load_request(request, [success_callback, request](ReadonlyBytes data, Requests::RequestTimingInfo const& timing_info, HTTP::HeaderMap const& response_headers) {
-            log_success(request);
-            success_callback->function()(data, timing_info, response_headers, {}, {});
-        });
-        return;
-    }
-
-    if (url.scheme() == "data") {
-        auto data_url_or_error = Fetch::Infrastructure::process_data_url(url);
-        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, {}, {}, {}, {}, {});
-            return;
-        }
-        auto data_url = data_url_or_error.release_value();
-
-        dbgln_if(SPAM_DEBUG, "ResourceLoader loading a data URL with mime-type: '{}', payload='{}'",
-            data_url.mime_type.serialized(),
-            StringView(data_url.body.bytes()));
-
-        HTTP::HeaderMap response_headers;
-        response_headers.set("Content-Type", data_url.mime_type.serialized().to_byte_string());
-
-        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] {
-            // FIXME: Implement timing info for data requests.
-            Requests::RequestTimingInfo fixme_implement_timing_info {};
-
-            success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {});
-        }));
-        return;
-    }
-
-    if (url.scheme() == "resource") {
-        handle_resource_load_request(
-            request,
-            [success_callback, request](FileLoadResult const& load_result) {
-                log_success(request);
-                success_callback->function()(load_result.data, load_result.timing_info, load_result.response_headers, {}, {});
-            },
-            [error_callback, request](ByteString const& error_message) {
-                log_failure(request, error_message);
-                if (error_callback)
-                    error_callback->function()(error_message, {}, {}, {}, {}, {});
-            });
-        return;
-    }
-
-    if (url.scheme() == "file") {
-        handle_file_load_request(
-            request,
-            [success_callback, request](FileLoadResult const& load_result) {
-                log_success(request);
-                success_callback->function()(load_result.data, load_result.timing_info, load_result.response_headers, {}, {});
-            },
-            [error_callback, request](ByteString const& error_message) {
-                log_failure(request, error_message);
-                if (error_callback)
-                    error_callback->function()(error_message, {}, {}, {}, {}, {});
-            });
-
-        return;
-    }
-
-    if (url.scheme() == "http" || url.scheme() == "https") {
-        auto protocol_request = start_network_request(request);
-        if (!protocol_request) {
-            if (error_callback)
-                error_callback->function()("Failed to start network request"sv, {}, {}, {}, {}, {});
-            return;
-        }
-
-        if (timeout.has_value() && timeout.value() > 0) {
-            auto timer = Platform::Timer::create_single_shot(m_heap, timeout.value(), nullptr);
-            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)
-                    timeout_callback->function()();
-            });
-            timer->start();
-        }
-
-        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
-            //       event loop inside a callback may cause this function object to be destroyed
-            //       while we're still calling it.
-            ScopeGuard cleanup = [&] {
-                deferred_invoke([this, protocol_request = NonnullRefPtr(protocol_request)] {
-                    finish_network_request(move(protocol_request));
-                });
-            };
-            if (network_error.has_value() || (status_code.has_value() && *status_code >= 400 && *status_code <= 599 && (payload.is_empty() || !request.is_main_resource()))) {
-                StringBuilder error_builder;
-                if (network_error.has_value())
-                    error_builder.appendff("{}", Requests::network_error_to_string(*network_error));
-                else
-                    error_builder.append("Load failed"sv);
-
-                if (status_code.has_value()) {
-                    if (*status_code >= 100 && *status_code <= 599)
-                        error_builder.appendff(" (status: {} {})", *status_code, HTTP::HttpResponse::reason_phrase_for_code(*status_code));
-                    else
-                        error_builder.appendff(" (status: {})", *status_code);
-                }
-
-                log_failure(request, error_builder.string_view());
-                if (error_callback)
-                    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, timing_info, response_headers, status_code, reason_phrase);
-        };
-
-        protocol_request->set_buffered_request_finished_callback(move(on_buffered_request_finished));
-        return;
-    }
-
-    auto not_implemented_error = ByteString::formatted("Protocol not implemented: {}", url.scheme());
-    log_failure(request, not_implemented_error);
-    if (error_callback) {
-        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)
+void ResourceLoader::load(LoadRequest& request, GC::Root<OnHeadersReceived> on_headers_received, GC::Root<OnDataReceived> on_data_received, GC::Root<OnComplete> on_complete)
 {
     auto const& url = request.url().value();
 

Libraries/LibWeb/Loader/ResourceLoader.h

@@ -30,17 +30,11 @@ class WEB_API ResourceLoader : public Core::EventReceiver {
 
     void set_client(NonnullRefPtr<Requests::RequestClient>);
 
-    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&, 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, Requests::RequestTimingInfo const& timing_info, Optional<StringView> error_message)>;
 
-    void load_unbuffered(LoadRequest&, GC::Root<OnHeadersReceived>, GC::Root<OnDataReceived>, GC::Root<OnComplete>);
+    void load(LoadRequest&, GC::Root<OnHeadersReceived>, GC::Root<OnDataReceived>, GC::Root<OnComplete>);
 
     RefPtr<Requests::RequestClient>& request_client() { return m_request_client; }