LibWeb+WebContent: Rename the http-cache flag to http-memory-cache

trflynn89 · awesomekling · commit adcf5462af9b · 2025-12-02T12:19:42.000+01:00
Rather than having http-cache and http-disk-cache, let's rename the
former to http-memory-cache to be extra clear what we are talking about.
diff --git a/AK/Debug.h.in b/AK/Debug.h.in
@@ -106,8 +106,8 @@
 #    cmakedefine01 HTML_SCRIPT_DEBUG
 #endif
 
-#ifndef HTTP_CACHE_DEBUG
-#    cmakedefine01 HTTP_CACHE_DEBUG
+#ifndef HTTP_MEMORY_CACHE_DEBUG
+#    cmakedefine01 HTTP_MEMORY_CACHE_DEBUG
 #endif
 
 #ifndef HTTPJOB_DEBUG
diff --git a/Libraries/LibWeb/Fetch/Fetching/Fetching.cpp b/Libraries/LibWeb/Fetch/Fetching/Fetching.cpp
@@ -70,7 +70,7 @@
 
 namespace Web::Fetch::Fetching {
 
-bool g_http_cache_enabled = false;
+bool g_http_memory_cache_enabled = false;
 
 #define TRY_OR_IGNORE(expression)                                                                    \
     ({                                                                                               \
@@ -1424,14 +1424,14 @@ class CachePartition : public RefCounted<CachePartition> {
         // - the presented target URI (Section 7.1 of [HTTP]) and that of the stored response match, and
         auto it = m_cache.find(url);
         if (it == m_cache.end()) {
-            dbgln_if(HTTP_CACHE_DEBUG, "\033[31;1mHTTP CACHE MISS!\033[0m {}", url);
+            dbgln_if(HTTP_MEMORY_CACHE_DEBUG, "\033[31;1mHTTP CACHE MISS!\033[0m {}", url);
             return {};
         }
         auto const& cached_response = it->value;
 
         // - the request method associated with the stored response allows it to be used for the presented request, and
         if (method != cached_response->method()) {
-            dbgln_if(HTTP_CACHE_DEBUG, "\033[31;1mHTTP CACHE MISS!\033[0m (Bad method) {}", url);
+            dbgln_if(HTTP_MEMORY_CACHE_DEBUG, "\033[31;1mHTTP CACHE MISS!\033[0m (Bad method) {}", url);
             return {};
         }
 
@@ -1445,7 +1445,7 @@ class CachePartition : public RefCounted<CachePartition> {
         //          + allowed to be served stale (see Section 4.2.4), or
         //          + successfully validated (see Section 4.3).
 
-        dbgln_if(HTTP_CACHE_DEBUG, "\033[32;1mHTTP CACHE HIT!\033[0m {}", url);
+        dbgln_if(HTTP_MEMORY_CACHE_DEBUG, "\033[32;1mHTTP CACHE HIT!\033[0m {}", url);
         return cached_response->clone(realm);
     }
 
@@ -1498,7 +1498,7 @@ class HTTPCache {
 // https://fetch.spec.whatwg.org/#determine-the-http-cache-partition
 static RefPtr<CachePartition> determine_the_http_cache_partition(Infrastructure::Request const& request)
 {
-    if (!g_http_cache_enabled)
+    if (!g_http_memory_cache_enabled)
         return nullptr;
 
     // 1. Let key be the result of determining the network partition key given request.
@@ -1905,7 +1905,7 @@ GC::Ref<PendingResponse> http_network_or_cache_fetch(JS::Realm& realm, Infrastru
 
             // 4. If the revalidatingFlag is set and forwardResponse’s status is 304, then:
             if (revalidating_flag->value() && forward_response->status() == 304) {
-                dbgln_if(HTTP_CACHE_DEBUG, "\033[34;1mHTTP CACHE REVALIDATE (304)\033[0m {}", http_request->current_url());
+                dbgln_if(HTTP_MEMORY_CACHE_DEBUG, "\033[34;1mHTTP CACHE REVALIDATE (304)\033[0m {}", http_request->current_url());
 
                 // 1. Update storedResponse’s header list using forwardResponse’s header list, as per the "Freshening
                 //    Stored Responses upon Validation" chapter of HTTP Caching.
@@ -2524,17 +2524,17 @@ void append_fetch_metadata_headers_for_request(Infrastructure::Request& request)
     set_sec_fetch_user_header(request);
 }
 
-void set_http_cache_enabled(bool const enabled)
+void set_http_memory_cache_enabled(bool const enabled)
 {
-    g_http_cache_enabled = enabled;
+    g_http_memory_cache_enabled = enabled;
 }
 
-bool http_cache_enabled()
+bool http_memory_cache_enabled()
 {
-    return g_http_cache_enabled;
+    return g_http_memory_cache_enabled;
 }
 
-void clear_http_cache()
+void clear_http_memory_cache()
 {
     HTTPCache::the().clear_cache();
 }
diff --git a/Libraries/LibWeb/Fetch/Fetching/Fetching.h b/Libraries/LibWeb/Fetch/Fetching/Fetching.h
@@ -55,8 +55,8 @@ void set_sec_fetch_site_header(Infrastructure::Request&);
 void set_sec_fetch_user_header(Infrastructure::Request&);
 void append_fetch_metadata_headers_for_request(Infrastructure::Request&);
 
-WEB_API void set_http_cache_enabled(bool enabled);
-WEB_API bool http_cache_enabled();
-WEB_API void clear_http_cache();
+WEB_API void set_http_memory_cache_enabled(bool enabled);
+WEB_API bool http_memory_cache_enabled();
+WEB_API void clear_http_memory_cache();
 
 }
diff --git a/Libraries/LibWeb/Internals/Internals.cpp b/Libraries/LibWeb/Internals/Internals.cpp
@@ -301,8 +301,8 @@ void Internals::expire_cookies_with_time_offset(WebIDL::LongLong seconds)
 
 bool Internals::set_http_memory_cache_enabled(bool enabled)
 {
-    auto was_enabled = Web::Fetch::Fetching::http_cache_enabled();
-    Web::Fetch::Fetching::set_http_cache_enabled(enabled);
+    auto was_enabled = Web::Fetch::Fetching::http_memory_cache_enabled();
+    Web::Fetch::Fetching::set_http_memory_cache_enabled(enabled);
     return was_enabled;
 }
 
diff --git a/Libraries/LibWebView/Application.cpp b/Libraries/LibWebView/Application.cpp
@@ -117,7 +117,7 @@ ErrorOr<void> Application::initialize(Main::Arguments const& arguments)
     bool log_all_js_exceptions = false;
     bool disable_site_isolation = false;
     bool enable_idl_tracing = false;
-    bool disable_http_cache = false;
+    bool disable_http_memory_cache = false;
     bool enable_http_disk_cache = false;
     bool disable_content_filter = false;
     bool enable_autoplay = false;
@@ -168,7 +168,7 @@ ErrorOr<void> Application::initialize(Main::Arguments const& arguments)
     args_parser.add_option(log_all_js_exceptions, "Log all JavaScript exceptions", "log-all-js-exceptions");
     args_parser.add_option(disable_site_isolation, "Disable site isolation", "disable-site-isolation");
     args_parser.add_option(enable_idl_tracing, "Enable IDL tracing", "enable-idl-tracing");
-    args_parser.add_option(disable_http_cache, "Disable HTTP cache", "disable-http-cache");
+    args_parser.add_option(disable_http_memory_cache, "Disable HTTP memory cache", "disable-http-memory-cache");
     args_parser.add_option(enable_http_disk_cache, "Enable HTTP disk cache", "enable-http-disk-cache");
     args_parser.add_option(disable_content_filter, "Disable content filter", "disable-content-filter");
     args_parser.add_option(enable_autoplay, "Enable multimedia autoplay", "enable-autoplay");
@@ -273,7 +273,7 @@ ErrorOr<void> Application::initialize(Main::Arguments const& arguments)
         .log_all_js_exceptions = log_all_js_exceptions ? LogAllJSExceptions::Yes : LogAllJSExceptions::No,
         .disable_site_isolation = disable_site_isolation ? DisableSiteIsolation::Yes : DisableSiteIsolation::No,
         .enable_idl_tracing = enable_idl_tracing ? EnableIDLTracing::Yes : EnableIDLTracing::No,
-        .enable_http_cache = disable_http_cache ? EnableHTTPCache::No : EnableHTTPCache::Yes,
+        .enable_http_memory_cache = disable_http_memory_cache ? EnableMemoryHTTPCache::No : EnableMemoryHTTPCache::Yes,
         .expose_internals_object = expose_internals_object ? ExposeInternalsObject::Yes : ExposeInternalsObject::No,
         .force_cpu_painting = force_cpu_painting ? ForceCPUPainting::Yes : ForceCPUPainting::No,
         .force_fontconfig = force_fontconfig ? ForceFontconfig::Yes : ForceFontconfig::No,
diff --git a/Libraries/LibWebView/HelperProcess.cpp b/Libraries/LibWebView/HelperProcess.cpp
@@ -110,8 +110,8 @@ static ErrorOr<NonnullRefPtr<WebView::WebContentClient>> launch_web_content_proc
         arguments.append("--disable-site-isolation"sv);
     if (web_content_options.enable_idl_tracing == WebView::EnableIDLTracing::Yes)
         arguments.append("--enable-idl-tracing"sv);
-    if (web_content_options.enable_http_cache == WebView::EnableHTTPCache::Yes)
-        arguments.append("--enable-http-cache"sv);
+    if (web_content_options.enable_http_memory_cache == WebView::EnableMemoryHTTPCache::Yes)
+        arguments.append("--enable-http-memory-cache"sv);
     if (web_content_options.expose_internals_object == WebView::ExposeInternalsObject::Yes)
         arguments.append("--expose-internals-object"sv);
     if (web_content_options.force_cpu_painting == WebView::ForceCPUPainting::Yes)
diff --git a/Libraries/LibWebView/Options.h b/Libraries/LibWebView/Options.h
@@ -119,7 +119,7 @@ enum class EnableIDLTracing {
     Yes,
 };
 
-enum class EnableHTTPCache {
+enum class EnableMemoryHTTPCache {
     No,
     Yes,
 };
@@ -163,7 +163,7 @@ struct WebContentOptions {
     LogAllJSExceptions log_all_js_exceptions { LogAllJSExceptions::No };
     DisableSiteIsolation disable_site_isolation { DisableSiteIsolation::No };
     EnableIDLTracing enable_idl_tracing { EnableIDLTracing::No };
-    EnableHTTPCache enable_http_cache { EnableHTTPCache::No };
+    EnableMemoryHTTPCache enable_http_memory_cache { EnableMemoryHTTPCache::No };
     ExposeInternalsObject expose_internals_object { ExposeInternalsObject::No };
     ForceCPUPainting force_cpu_painting { ForceCPUPainting::No };
     ForceFontconfig force_fontconfig { ForceFontconfig::No };
diff --git a/Meta/CMake/all_the_debug_macros.cmake b/Meta/CMake/all_the_debug_macros.cmake
@@ -22,7 +22,7 @@ set(GIF_DEBUG ON)
 set(HEAP_DEBUG ON)
 set(HIGHLIGHT_FOCUSED_FRAME_DEBUG ON)
 set(HTML_SCRIPT_DEBUG ON)
-set(HTTP_CACHE_DEBUG ON)
+set(HTTP_MEMORY_CACHE_DEBUG ON)
 set(HTTPJOB_DEBUG ON)
 set(HUNKS_DEBUG ON)
 set(ICO_DEBUG ON)
diff --git a/Services/WebContent/ConnectionFromClient.cpp b/Services/WebContent/ConnectionFromClient.cpp
@@ -387,7 +387,7 @@ void ConnectionFromClient::debug_request(u64 page_id, ByteString request, ByteSt
     }
 
     if (request == "clear-cache") {
-        Web::Fetch::Fetching::clear_http_cache();
+        Web::Fetch::Fetching::clear_http_memory_cache();
         return;
     }
 
diff --git a/Services/WebContent/main.cpp b/Services/WebContent/main.cpp
@@ -80,7 +80,7 @@ ErrorOr<int> ladybird_main(Main::Arguments arguments)
     bool log_all_js_exceptions = false;
     bool disable_site_isolation = false;
     bool enable_idl_tracing = false;
-    bool enable_http_cache = false;
+    bool enable_http_memory_cache = false;
     bool force_cpu_painting = false;
     bool force_fontconfig = false;
     bool collect_garbage_on_every_allocation = false;
@@ -103,7 +103,7 @@ ErrorOr<int> ladybird_main(Main::Arguments arguments)
     args_parser.add_option(log_all_js_exceptions, "Log all JavaScript exceptions", "log-all-js-exceptions");
     args_parser.add_option(disable_site_isolation, "Disable site isolation", "disable-site-isolation");
     args_parser.add_option(enable_idl_tracing, "Enable IDL tracing", "enable-idl-tracing");
-    args_parser.add_option(enable_http_cache, "Enable HTTP cache", "enable-http-cache");
+    args_parser.add_option(enable_http_memory_cache, "Enable HTTP cache", "enable-http-memory-cache");
     args_parser.add_option(force_cpu_painting, "Force CPU painting", "force-cpu-painting");
     args_parser.add_option(force_fontconfig, "Force using fontconfig for font loading", "force-fontconfig");
     args_parser.add_option(collect_garbage_on_every_allocation, "Collect garbage after every JS heap allocation", "collect-garbage-on-every-allocation");
@@ -146,10 +146,8 @@ ErrorOr<int> ladybird_main(Main::Arguments arguments)
     if (disable_site_isolation)
         WebView::disable_site_isolation();
 
-    if (enable_http_cache) {
-
-        Web::Fetch::Fetching::set_http_cache_enabled(true);
-    }
+    if (enable_http_memory_cache)
+        Web::Fetch::Fetching::set_http_memory_cache_enabled(true);
 
     Web::Painting::set_paint_viewport_scrollbars(!disable_scrollbar_painting);
 

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@`
`70`	`70`
`71`	`71`	`namespace Web::Fetch::Fetching {`
`72`	`72`
`73`		`-bool g_http_cache_enabled = false;`
	`73`	`+bool g_http_memory_cache_enabled = false;`
`74`	`74`
`75`	`75`	`#define TRY_OR_IGNORE(expression) \`
`76`	`76`	`({ \`
`@@ -1424,14 +1424,14 @@ class CachePartition : public RefCounted<CachePartition> {`
`1424`	`1424`	`// - the presented target URI (Section 7.1 of [HTTP]) and that of the stored response match, and`
`1425`	`1425`	`auto it = m_cache.find(url);`
`1426`	`1426`	`if (it == m_cache.end()) {`
`1427`		`- dbgln_if(HTTP_CACHE_DEBUG, "\033[31;1mHTTP CACHE MISS!\033[0m {}", url);`
	`1427`	`+ dbgln_if(HTTP_MEMORY_CACHE_DEBUG, "\033[31;1mHTTP CACHE MISS!\033[0m {}", url);`
`1428`	`1428`	`return {};`
`1429`	`1429`	`}`
`1430`	`1430`	`auto const& cached_response = it->value;`
`1431`	`1431`
`1432`	`1432`	`// - the request method associated with the stored response allows it to be used for the presented request, and`
`1433`	`1433`	`if (method != cached_response->method()) {`
`1434`		`- dbgln_if(HTTP_CACHE_DEBUG, "\033[31;1mHTTP CACHE MISS!\033[0m (Bad method) {}", url);`
	`1434`	`+ dbgln_if(HTTP_MEMORY_CACHE_DEBUG, "\033[31;1mHTTP CACHE MISS!\033[0m (Bad method) {}", url);`
`1435`	`1435`	`return {};`
`1436`	`1436`	`}`
`1437`	`1437`
`@@ -1445,7 +1445,7 @@ class CachePartition : public RefCounted<CachePartition> {`
`1445`	`1445`	`// + allowed to be served stale (see Section 4.2.4), or`
`1446`	`1446`	`// + successfully validated (see Section 4.3).`
`1447`	`1447`
`1448`		`- dbgln_if(HTTP_CACHE_DEBUG, "\033[32;1mHTTP CACHE HIT!\033[0m {}", url);`
	`1448`	`+ dbgln_if(HTTP_MEMORY_CACHE_DEBUG, "\033[32;1mHTTP CACHE HIT!\033[0m {}", url);`
`1449`	`1449`	`return cached_response->clone(realm);`
`1450`	`1450`	`}`
`1451`	`1451`
`@@ -1498,7 +1498,7 @@ class HTTPCache {`
`1498`	`1498`	`// https://fetch.spec.whatwg.org/#determine-the-http-cache-partition`
`1499`	`1499`	`static RefPtr<CachePartition> determine_the_http_cache_partition(Infrastructure::Request const& request)`
`1500`	`1500`	`{`
`1501`		`- if (!g_http_cache_enabled)`
	`1501`	`+ if (!g_http_memory_cache_enabled)`
`1502`	`1502`	`return nullptr;`
`1503`	`1503`
`1504`	`1504`	`// 1. Let key be the result of determining the network partition key given request.`
`@@ -1905,7 +1905,7 @@ GC::Ref<PendingResponse> http_network_or_cache_fetch(JS::Realm& realm, Infrastru`
`1905`	`1905`
`1906`	`1906`	`// 4. If the revalidatingFlag is set and forwardResponse’s status is 304, then:`
`1907`	`1907`	`if (revalidating_flag->value() && forward_response->status() == 304) {`
`1908`		`- dbgln_if(HTTP_CACHE_DEBUG, "\033[34;1mHTTP CACHE REVALIDATE (304)\033[0m {}", http_request->current_url());`
	`1908`	`+ dbgln_if(HTTP_MEMORY_CACHE_DEBUG, "\033[34;1mHTTP CACHE REVALIDATE (304)\033[0m {}", http_request->current_url());`
`1909`	`1909`
`1910`	`1910`	`// 1. Update storedResponse’s header list using forwardResponse’s header list, as per the "Freshening`
`1911`	`1911`	`// Stored Responses upon Validation" chapter of HTTP Caching.`
`@@ -2524,17 +2524,17 @@ void append_fetch_metadata_headers_for_request(Infrastructure::Request& request)`
`2524`	`2524`	`set_sec_fetch_user_header(request);`
`2525`	`2525`	`}`
`2526`	`2526`
`2527`		`-void set_http_cache_enabled(bool const enabled)`
	`2527`	`+void set_http_memory_cache_enabled(bool const enabled)`
`2528`	`2528`	`{`
`2529`		`- g_http_cache_enabled = enabled;`
	`2529`	`+ g_http_memory_cache_enabled = enabled;`
`2530`	`2530`	`}`
`2531`	`2531`
`2532`		`-bool http_cache_enabled()`
	`2532`	`+bool http_memory_cache_enabled()`
`2533`	`2533`	`{`
`2534`		`- return g_http_cache_enabled;`
	`2534`	`+ return g_http_memory_cache_enabled;`
`2535`	`2535`	`}`
`2536`	`2536`
`2537`		`-void clear_http_cache()`
	`2537`	`+void clear_http_memory_cache()`
`2538`	`2538`	`{`
`2539`	`2539`	`HTTPCache::the().clear_cache();`
`2540`	`2540`	`}`
Original file line number	Diff line number	Diff line change
`@@ -301,8 +301,8 @@ void Internals::expire_cookies_with_time_offset(WebIDL::LongLong seconds)`
`301`	`301`
`302`	`302`	`bool Internals::set_http_memory_cache_enabled(bool enabled)`
`303`	`303`	`{`
`304`		`- auto was_enabled = Web::Fetch::Fetching::http_cache_enabled();`
`305`		`- Web::Fetch::Fetching::set_http_cache_enabled(enabled);`
	`304`	`+ auto was_enabled = Web::Fetch::Fetching::http_memory_cache_enabled();`
	`305`	`+ Web::Fetch::Fetching::set_http_memory_cache_enabled(enabled);`
`306`	`306`	`return was_enabled;`
`307`	`307`	`}`
`308`	`308`
Original file line number	Diff line number	Diff line change
`@@ -387,7 +387,7 @@ void ConnectionFromClient::debug_request(u64 page_id, ByteString request, ByteSt`
`387`	`387`	`}`
`388`	`388`
`389`	`389`	`if (request == "clear-cache") {`
`390`		`- Web::Fetch::Fetching::clear_http_cache();`
	`390`	`+ Web::Fetch::Fetching::clear_http_memory_cache();`
`391`	`391`	`return;`
`392`	`392`	`}`
`393`	`393`