LibWeb: Add a naive Resource cache

This patch introduces a caching mechanism in ResourceLoader. It's keyed
on a LoadRequest object which is what you provide to load_resource()
when you want to load a resource.

We currently never prune the cache, so resources will stay in there
forever. This is obviously not gonna stay that way, but we're just
getting started here. :^)

This should drastically reduce the number of requests when loading
some sites (like Twitter) that reuse the same images over and over.

Libraries/LibWeb/Loader/LoadRequest.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <AK/URL.h>
+#include <LibWeb/Forward.h>
+
+namespace Web {
+
+class LoadRequest {
+public:
+    LoadRequest()
+    {
+    }
+
+    bool is_valid() const { return m_url.is_valid(); }
+
+    const URL& url() const { return m_url; }
+    void set_url(const URL& url) { m_url = url; }
+
+    unsigned hash() const { return m_url.to_string().hash(); }
+
+    bool operator==(const LoadRequest& other) const
+    {
+        return m_url == other.m_url;
+    }
+
+private:
+    URL m_url;
+};
+
+}
+
+namespace AK {
+
+template<>
+struct Traits<Web::LoadRequest> : public GenericTraits<Web::LoadRequest> {
+    static unsigned hash(const Web::LoadRequest& request) { return request.hash(); }
+};
+
+}

Libraries/LibWeb/Loader/Resource.cpp

@@ -29,13 +29,13 @@
 
 namespace Web {
 
-NonnullRefPtr<Resource> Resource::create(Badge<ResourceLoader>, const URL& url)
+NonnullRefPtr<Resource> Resource::create(Badge<ResourceLoader>, const LoadRequest& request)
 {
-    return adopt(*new Resource(url));
+    return adopt(*new Resource(request));
 }
 
-Resource::Resource(const URL& url)
-    : m_url(url)
+Resource::Resource(const LoadRequest& request)
+    : m_request(request)
 {
 }
 

Libraries/LibWeb/Loader/Resource.h

@@ -33,6 +33,7 @@
 #include <AK/RefCounted.h>
 #include <AK/URL.h>
 #include <LibWeb/Forward.h>
+#include <LibWeb/Loader/LoadRequest.h>
 
 namespace Web {
 
@@ -43,7 +44,7 @@ class Resource : public RefCounted<Resource> {
     AK_MAKE_NONMOVABLE(Resource);
 
 public:
-    static NonnullRefPtr<Resource> create(Badge<ResourceLoader>, const URL&);
+    static NonnullRefPtr<Resource> create(Badge<ResourceLoader>, const LoadRequest&);
     ~Resource();
 
     bool is_loaded() const { return m_loaded; }
@@ -53,7 +54,7 @@ public:
 
     bool has_encoded_data() const { return !m_encoded_data.is_null(); }
 
-    const URL& url() const { return m_url; }
+    const URL& url() const { return m_request.url(); }
     const ByteBuffer& encoded_data() const { return m_encoded_data; }
 
     void register_client(Badge<ResourceClient>, ResourceClient&);
@@ -75,9 +76,9 @@ public:
     void did_fail(Badge<ResourceLoader>, const String& error);
 
 private:
-    explicit Resource(const URL&);
+    explicit Resource(const LoadRequest&);
 
-    URL m_url;
+    LoadRequest m_request;
     ByteBuffer m_encoded_data;
     bool m_loaded { false };
     bool m_failed { false };

Libraries/LibWeb/Loader/ResourceLoader.cpp

@@ -31,6 +31,7 @@
 #include <LibCore/File.h>
 #include <LibProtocol/Client.h>
 #include <LibProtocol/Download.h>
+#include <LibWeb/Loader/LoadRequest.h>
 #include <LibWeb/Loader/Resource.h>
 #include <LibWeb/Loader/ResourceLoader.h>
 
@@ -69,15 +70,25 @@ void ResourceLoader::load_sync(const URL& url, Function<void(const ByteBuffer&,
     loop.exec();
 }
 
-RefPtr<Resource> ResourceLoader::load_resource(const URL& url)
+static HashMap<LoadRequest, NonnullRefPtr<Resource>> s_resource_cache;
+
+RefPtr<Resource> ResourceLoader::load_resource(const LoadRequest& request)
 {
-    if (!url.is_valid())
+    if (!request.is_valid())
         return nullptr;
 
-    auto resource = Resource::create({}, url);
+    auto it = s_resource_cache.find(request);
+    if (it != s_resource_cache.end()) {
+        dbg() << "Reusing cached resource for: " << request.url();
+        return it->value;
+    }
+
+    auto resource = Resource::create({}, request);
+
+    s_resource_cache.set(request, resource);
 
     load(
-        url,
+        request.url(),
         [=](auto& data, auto& headers) {
             const_cast<Resource&>(*resource).did_load({}, data, headers);
         },

Libraries/LibWeb/Loader/ResourceLoader.h

@@ -42,7 +42,7 @@ class ResourceLoader : public Core::Object {
 public:
     static ResourceLoader& the();
 
-    RefPtr<Resource> load_resource(const URL&);
+    RefPtr<Resource> load_resource(const LoadRequest&);
 
     void load(const URL&, Function<void(const ByteBuffer&, const HashMap<String, String, CaseInsensitiveStringTraits>& response_headers)> success_callback, Function<void(const String&)> error_callback = nullptr);
     void load_sync(const URL&, Function<void(const ByteBuffer&, const HashMap<String, String, CaseInsensitiveStringTraits>& response_headers)> success_callback, Function<void(const String&)> error_callback = nullptr);