dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Libraries/LibWeb/Loader/ContentBlocker.cpp

357 lines
12 KiB
C++
Raw Permalink Normal View History

LibWeb: Add a basic content filter (ad blocking!) :^) This patch adds a global (per-process) filter list to LibWeb that is used to filter all outgoing resource load requests. Basically we check the URL against a list of filter patterns and if it's a match for any one of them, we immediately fail the load. The filter list is a simple text file: ~/.config/BrowserContentFilters.txt It's one filter per line and they are simple glob filters for now, with implicit asterisks (*) at the start and end of the line.
2021-01-05 14:12:29 -03:00
/*
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
* Copyright (c) 2026-present, the Ladybird developers.
LibWeb: Add a basic content filter (ad blocking!) :^) This patch adds a global (per-process) filter list to LibWeb that is used to filter all outgoing resource load requests. Basically we check the URL against a list of filter patterns and if it's a match for any one of them, we immediately fail the load. The filter list is a simple text file: ~/.config/BrowserContentFilters.txt It's one filter per line and they are simple glob filters for now, with implicit asterisks (*) at the start and end of the line.
2021-01-05 14:12:29 -03:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 05:24:48 -03:00
* SPDX-License-Identifier: BSD-2-Clause
LibWeb: Add a basic content filter (ad blocking!) :^) This patch adds a global (per-process) filter list to LibWeb that is used to filter all outgoing resource load requests. Basically we check the URL against a list of filter patterns and if it's a match for any one of them, we immediately fail the load. The filter list is a simple text file: ~/.config/BrowserContentFilters.txt It's one filter per line and they are simple glob filters for now, with implicit asterisks (*) at the start and end of the line.
2021-01-05 14:12:29 -03:00
*/
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
#include <AK/ScopeGuard.h>
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
#include <AK/StringBuilder.h>
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
#include <AK/Vector.h>
LibWeb: Thread request context into ContentBlocker Carry the initiating URL, fetch destination, initiator type, and request mode from Fetch into LoadRequest and pass them to ContentBlocker. The existing substring matcher still matches only the request URL, but the blocker API now receives the context needed by source-aware backends. Preserve that metadata for CORS preflights and connection hints, and add coverage for resource-type mapping and blob source URL normalization.
2026-05-21 11:44:02 -03:00
#include <LibURL/Parser.h>
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
#include <LibWeb/ContentBlockerRustFFI.h>
LibWeb: Rename ContentFilter to ContentBlocker Rename the local content blocking implementation and its tests from ContentFilter to ContentBlocker while keeping the existing substring matcher backend and behavior. Update the WebContent IPC method, WebView option names, debug toggle, and default config file name to use content blocker terminology.
2026-05-21 11:36:25 -03:00
#include <LibWeb/Loader/ContentBlocker.h>
LibWeb: Add a basic content filter (ad blocking!) :^) This patch adds a global (per-process) filter list to LibWeb that is used to filter all outgoing resource load requests. Basically we check the URL against a list of filter patterns and if it's a match for any one of them, we immediately fail the load. The filter list is a simple text file: ~/.config/BrowserContentFilters.txt It's one filter per line and they are simple glob filters for now, with implicit asterisks (*) at the start and end of the line.
2021-01-05 14:12:29 -03:00
namespace Web {
LibWeb: Rename ContentFilter to ContentBlocker Rename the local content blocking implementation and its tests from ContentFilter to ContentBlocker while keeping the existing substring matcher backend and behavior. Update the WebContent IPC method, WebView option names, debug toggle, and default config file name to use content blocker terminology.
2026-05-21 11:36:25 -03:00
ContentBlocker& ContentBlocker::the()
LibWeb: Add a basic content filter (ad blocking!) :^) This patch adds a global (per-process) filter list to LibWeb that is used to filter all outgoing resource load requests. Basically we check the URL against a list of filter patterns and if it's a match for any one of them, we immediately fail the load. The filter list is a simple text file: ~/.config/BrowserContentFilters.txt It's one filter per line and they are simple glob filters for now, with implicit asterisks (*) at the start and end of the line.
2021-01-05 14:12:29 -03:00
{
Meta: Enable exit-time destructor warnings for libraries Enable -Wexit-time-destructors for all in-tree library targets and update process-lifetime library statics so they no longer register exit-time destructors. Long-lived caches, lookup tables, singleton registries, and generated constants now use NeverDestroyed or leaked references where the data is intended to live until process exit. Update LibWeb, LibLine, and the binding generators so regenerated sources follow the same rule instead of reintroducing destructed statics.
2026-06-04 05:40:32 -03:00
static ContentBlocker& blocker = *new ContentBlocker;
LibWeb: Rename ContentFilter to ContentBlocker Rename the local content blocking implementation and its tests from ContentFilter to ContentBlocker while keeping the existing substring matcher backend and behavior. Update the WebContent IPC method, WebView option names, debug toggle, and default config file name to use content blocker terminology.
2026-05-21 11:36:25 -03:00
return blocker;
LibWeb: Add a basic content filter (ad blocking!) :^) This patch adds a global (per-process) filter list to LibWeb that is used to filter all outgoing resource load requests. Basically we check the URL against a list of filter patterns and if it's a match for any one of them, we immediately fail the load. The filter list is a simple text file: ~/.config/BrowserContentFilters.txt It's one filter per line and they are simple glob filters for now, with implicit asterisks (*) at the start and end of the line.
2021-01-05 14:12:29 -03:00
}
LibWeb: Rename ContentFilter to ContentBlocker Rename the local content blocking implementation and its tests from ContentFilter to ContentBlocker while keeping the existing substring matcher backend and behavior. Update the WebContent IPC method, WebView option names, debug toggle, and default config file name to use content blocker terminology.
2026-05-21 11:36:25 -03:00
ContentBlocker::ContentBlocker() = default;
LibWeb: Add a basic content filter (ad blocking!) :^) This patch adds a global (per-process) filter list to LibWeb that is used to filter all outgoing resource load requests. Basically we check the URL against a list of filter patterns and if it's a match for any one of them, we immediately fail the load. The filter list is a simple text file: ~/.config/BrowserContentFilters.txt It's one filter per line and they are simple glob filters for now, with implicit asterisks (*) at the start and end of the line.
2021-01-05 14:12:29 -03:00
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
ContentBlocker::~ContentBlocker()
{
ContentBlocking::FFI::rust_content_blocker_free(m_engine);
}
LibWeb: Add a basic content filter (ad blocking!) :^) This patch adds a global (per-process) filter list to LibWeb that is used to filter all outgoing resource load requests. Basically we check the URL against a list of filter patterns and if it's a match for any one of them, we immediately fail the load. The filter list is a simple text file: ~/.config/BrowserContentFilters.txt It's one filter per line and they are simple glob filters for now, with implicit asterisks (*) at the start and end of the line.
2021-01-05 14:12:29 -03:00
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
static StringView resource_type_to_adblock_request_type(ContentBlocker::ResourceType type)
LibWeb: Add a basic content filter (ad blocking!) :^) This patch adds a global (per-process) filter list to LibWeb that is used to filter all outgoing resource load requests. Basically we check the URL against a list of filter patterns and if it's a match for any one of them, we immediately fail the load. The filter list is a simple text file: ~/.config/BrowserContentFilters.txt It's one filter per line and they are simple glob filters for now, with implicit asterisks (*) at the start and end of the line.
2021-01-05 14:12:29 -03:00
{
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
switch (type) {
case ContentBlocker::ResourceType::Document:
return "document"sv;
case ContentBlocker::ResourceType::Font:
return "font"sv;
case ContentBlocker::ResourceType::Image:
return "image"sv;
case ContentBlocker::ResourceType::Media:
return "media"sv;
case ContentBlocker::ResourceType::Object:
return "object"sv;
case ContentBlocker::ResourceType::Other:
return "other"sv;
case ContentBlocker::ResourceType::Ping:
return "ping"sv;
case ContentBlocker::ResourceType::Script:
return "script"sv;
case ContentBlocker::ResourceType::Stylesheet:
return "stylesheet"sv;
case ContentBlocker::ResourceType::Subdocument:
return "subdocument"sv;
case ContentBlocker::ResourceType::WebSocket:
return "websocket"sv;
case ContentBlocker::ResourceType::XMLHttpRequest:
return "xmlhttprequest"sv;
}
VERIFY_NOT_REACHED();
}
LibWeb/Loader: Add `filtering_enabled` flag in `ContentFilter` This allows us to toggle content filtering on or off. Default is set to true to match current behavior.
2025-03-06 20:42:40 -03:00
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
static ByteString serialized_url(URL::URL const& url)
{
return url.serialize().to_byte_string();
LibWeb: Use a faster string search algorithm for content filtering
2025-11-09 01:24:23 -03:00
}
LibWeb: Don't try to ad-block data: urls In some cases these can be several KiB or more in size, making checking very slow, and it doesn't make sense to filter them out anyway. This change speeds up loading pages with large data: urls, which previously took up to 1ms per byte to process.
2021-09-27 10:59:42 -03:00
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
static ByteString serialized_url_for_matching(URL::URL const& url)
LibWeb: Thread request context into ContentBlocker Carry the initiating URL, fetch destination, initiator type, and request mode from Fetch into LoadRequest and pass them to ContentBlocker. The existing substring matcher still matches only the request URL, but the blocker API now receives the context needed by source-aware backends. Preserve that metadata for CORS preflights and connection hints, and add coverage for resource-type mapping and blob source URL normalization.
2026-05-21 11:44:02 -03:00
{
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
if (url.scheme() == "file"sv)
return ByteString::formatted("http://local-file.invalid/{}", serialized_url(url));
return serialized_url(url);
LibWeb: Thread request context into ContentBlocker Carry the initiating URL, fetch destination, initiator type, and request mode from Fetch into LoadRequest and pass them to ContentBlocker. The existing substring matcher still matches only the request URL, but the blocker API now receives the context needed by source-aware backends. Preserve that metadata for CORS preflights and connection hints, and add coverage for resource-type mapping and blob source URL normalization.
2026-05-21 11:44:02 -03:00
}
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
static String take_rust_string(ContentBlocking::FFI::ContentBlockerString rust_string)
LibWeb: Thread request context into ContentBlocker Carry the initiating URL, fetch destination, initiator type, and request mode from Fetch into LoadRequest and pass them to ContentBlocker. The existing substring matcher still matches only the request URL, but the blocker API now receives the context needed by source-aware backends. Preserve that metadata for CORS preflights and connection hints, and add coverage for resource-type mapping and blob source URL normalization.
2026-05-21 11:44:02 -03:00
{
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
if (!rust_string.data)
return {};
ArmedScopeGuard free_string = [&] {
ContentBlocking::FFI::rust_content_blocker_free_string(rust_string.data, rust_string.length);
};
auto maybe_string = String::from_utf8({ reinterpret_cast<char const*>(rust_string.data), rust_string.length });
if (maybe_string.is_error())
return {};
return maybe_string.release_value();
}
static ErrorOr<String> join_lines(ReadonlySpan<String> lines)
{
StringBuilder builder;
for (auto const& line : lines) {
builder.append(line);
builder.append('\n');
}
return builder.to_string();
LibWeb: Thread request context into ContentBlocker Carry the initiating URL, fetch destination, initiator type, and request mode from Fetch into LoadRequest and pass them to ContentBlocker. The existing substring matcher still matches only the request URL, but the blocker API now receives the context needed by source-aware backends. Preserve that metadata for CORS preflights and connection hints, and add coverage for resource-type mapping and blob source URL normalization.
2026-05-21 11:44:02 -03:00
}
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
static bool line_looks_like_supported_cosmetic_rule(StringView line)
LibWeb: Use a faster string search algorithm for content filtering
2025-11-09 01:24:23 -03:00
{
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
auto trimmed_line = line.trim_whitespace();
if (trimmed_line.is_empty() || trimmed_line.starts_with('!') || trimmed_line.starts_with('['))
return false;
auto sharp_index = trimmed_line.find('#');
if (!sharp_index.has_value())
return false;
auto after_sharp_index = *sharp_index + 1;
if (after_sharp_index >= trimmed_line.length())
return false;
auto second_sharp_index = trimmed_line.find('#', after_sharp_index);
if (!second_sharp_index.has_value())
LibWeb: Use a faster string search algorithm for content filtering
2025-11-09 01:24:23 -03:00
return false;
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
auto between_sharps = trimmed_line.substring_view(after_sharp_index, *second_sharp_index - after_sharp_index);
if (between_sharps.starts_with('@')) {
if (*sharp_index == 0)
return false;
between_sharps = between_sharps.substring_view(1);
}
if (between_sharps.starts_with('?'))
between_sharps = between_sharps.substring_view(1);
return between_sharps.is_empty();
LibWeb: Add a basic content filter (ad blocking!) :^) This patch adds a global (per-process) filter list to LibWeb that is used to filter all outgoing resource load requests. Basically we check the URL against a list of filter patterns and if it's a match for any one of them, we immediately fail the load. The filter list is a simple text file: ~/.config/BrowserContentFilters.txt It's one filter per line and they are simple glob filters for now, with implicit asterisks (*) at the start and end of the line.
2021-01-05 14:12:29 -03:00
}
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
static bool rules_contain_cosmetic_rules(ReadonlyBytes rules_bytes)
LibWeb: Add a basic content filter (ad blocking!) :^) This patch adds a global (per-process) filter list to LibWeb that is used to filter all outgoing resource load requests. Basically we check the URL against a list of filter patterns and if it's a match for any one of them, we immediately fail the load. The filter list is a simple text file: ~/.config/BrowserContentFilters.txt It's one filter per line and they are simple glob filters for now, with implicit asterisks (*) at the start and end of the line.
2021-01-05 14:12:29 -03:00
{
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
bool has_cosmetic_rules = false;
StringView { rules_bytes }.for_each_split_view('\n', SplitBehavior::Nothing, [&](StringView line) {
if (line_looks_like_supported_cosmetic_rule(line))
has_cosmetic_rules = true;
});
return has_cosmetic_rules;
}
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
ErrorOr<void> ContentBlocker::set_patterns(ReadonlySpan<String> patterns)
{
StringBuilder builder;
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
for (auto const& pattern : patterns) {
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
if (pattern.is_empty())
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
continue;
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
builder.append(pattern);
builder.append('\n');
}
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
auto patterns_string = TRY(builder.to_string());
auto patterns_bytes = patterns_string.bytes_as_string_view().bytes();
return set_rules_from_bytes(patterns_bytes);
}
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
ErrorOr<void> ContentBlocker::set_rules_from_bytes(ReadonlyBytes rules_bytes)
{
auto* engine = ContentBlocking::FFI::rust_content_blocker_create(
rules_bytes.data(),
rules_bytes.size());
if (!engine)
return Error::from_string_literal("Failed to create content blocker");
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
auto has_cosmetic_rules = rules_contain_cosmetic_rules(rules_bytes);
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
ContentBlocking::FFI::rust_content_blocker_free(m_engine);
m_engine = engine;
m_has_cosmetic_rules = has_cosmetic_rules;
LibWeb: Use a faster string search algorithm for content filtering
2025-11-09 01:24:23 -03:00
return {};
}
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
bool ContentBlocker::is_filtered(URL::URL const& url) const
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
{
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
return is_filtered(url, url, ResourceType::Other);
}
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
bool ContentBlocker::is_filtered(URL::URL const& url, URL::URL const& source_url, Optional<Fetch::Infrastructure::Request::Destination> const& destination, Optional<Fetch::Infrastructure::Request::InitiatorType> const& initiator_type, Fetch::Infrastructure::Request::Mode mode) const
{
return is_filtered(url, source_url_for_matching(source_url), resource_type_from_fetch_metadata(destination, initiator_type, mode));
}
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
bool ContentBlocker::is_filtered(URL::URL const& url, URL::URL const& source_url, ResourceType resource_type) const
{
if (!filtering_enabled() || !m_engine)
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
return false;
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
if (url.scheme() == "data"sv)
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
return false;
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
auto url_string = serialized_url_for_matching(url);
auto normalized_source_url = source_url_for_matching(source_url);
auto source_url_string = serialized_url_for_matching(normalized_source_url);
auto request_type = resource_type_to_adblock_request_type(resource_type);
return ContentBlocking::FFI::rust_content_blocker_matches(
m_engine,
reinterpret_cast<u8 const*>(url_string.characters()),
url_string.length(),
reinterpret_cast<u8 const*>(source_url_string.characters()),
source_url_string.length(),
reinterpret_cast<u8 const*>(request_type.characters_without_null_termination()),
request_type.length());
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
}
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
String ContentBlocker::cosmetic_style_sheet_for_url(URL::URL const& url) const
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
{
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
return cosmetic_style_sheet_for_url(url, {}, {});
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
}
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
String ContentBlocker::cosmetic_style_sheet_for_url(URL::URL const& url, ReadonlySpan<String> classes, ReadonlySpan<String> ids) const
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
{
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
if (!filtering_enabled() || !m_engine || !m_has_cosmetic_rules)
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
return {};
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
auto url_string = serialized_url(url);
auto classes_string = join_lines(classes);
if (classes_string.is_error())
return {};
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
auto ids_string = join_lines(ids);
if (ids_string.is_error())
return {};
auto classes_bytes = classes_string.value().bytes_as_string_view();
auto ids_bytes = ids_string.value().bytes_as_string_view();
return take_rust_string(ContentBlocking::FFI::rust_content_blocker_cosmetic_css(
m_engine,
reinterpret_cast<u8 const*>(url_string.characters()),
url_string.length(),
reinterpret_cast<u8 const*>(classes_bytes.characters_without_null_termination()),
classes_bytes.length(),
reinterpret_cast<u8 const*>(ids_bytes.characters_without_null_termination()),
ids_bytes.length()));
}
LibWeb: Refresh blocker CSS after relevant class/id changes Refresh content blocker styles when connected elements gain or change class or id tokens that can affect generic cosmetic selectors. Cache the class and id tokens covered by each document's content blocker stylesheet, then ask the adblock engine whether newly-added tokens can unlock selectors before invalidating user style for the whole page. This keeps dynamic cosmetic hiding correct without refreshing blocker CSS for unrelated class and id mutations. Add text coverage for irrelevant class/id mutations that should preserve author style invalidation without refreshing blocker CSS. Also prove matching tokens still hide elements.
2026-05-23 17:28:30 -03:00
bool ContentBlocker::has_generic_cosmetic_selectors_for_url(URL::URL const& url, ReadonlySpan<String> classes, ReadonlySpan<String> ids) const
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
{
if (!filtering_enabled() || !m_engine || !m_has_cosmetic_rules)
LibWeb: Refresh blocker CSS after relevant class/id changes Refresh content blocker styles when connected elements gain or change class or id tokens that can affect generic cosmetic selectors. Cache the class and id tokens covered by each document's content blocker stylesheet, then ask the adblock engine whether newly-added tokens can unlock selectors before invalidating user style for the whole page. This keeps dynamic cosmetic hiding correct without refreshing blocker CSS for unrelated class and id mutations. Add text coverage for irrelevant class/id mutations that should preserve author style invalidation without refreshing blocker CSS. Also prove matching tokens still hide elements.
2026-05-23 17:28:30 -03:00
return false;
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
LibWeb: Refresh blocker CSS after relevant class/id changes Refresh content blocker styles when connected elements gain or change class or id tokens that can affect generic cosmetic selectors. Cache the class and id tokens covered by each document's content blocker stylesheet, then ask the adblock engine whether newly-added tokens can unlock selectors before invalidating user style for the whole page. This keeps dynamic cosmetic hiding correct without refreshing blocker CSS for unrelated class and id mutations. Add text coverage for irrelevant class/id mutations that should preserve author style invalidation without refreshing blocker CSS. Also prove matching tokens still hide elements.
2026-05-23 17:28:30 -03:00
auto url_string = serialized_url(url);
auto classes_string = join_lines(classes);
if (classes_string.is_error())
return false;
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
LibWeb: Refresh blocker CSS after relevant class/id changes Refresh content blocker styles when connected elements gain or change class or id tokens that can affect generic cosmetic selectors. Cache the class and id tokens covered by each document's content blocker stylesheet, then ask the adblock engine whether newly-added tokens can unlock selectors before invalidating user style for the whole page. This keeps dynamic cosmetic hiding correct without refreshing blocker CSS for unrelated class and id mutations. Add text coverage for irrelevant class/id mutations that should preserve author style invalidation without refreshing blocker CSS. Also prove matching tokens still hide elements.
2026-05-23 17:28:30 -03:00
auto ids_string = join_lines(ids);
if (ids_string.is_error())
return false;
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
LibWeb: Refresh blocker CSS after relevant class/id changes Refresh content blocker styles when connected elements gain or change class or id tokens that can affect generic cosmetic selectors. Cache the class and id tokens covered by each document's content blocker stylesheet, then ask the adblock engine whether newly-added tokens can unlock selectors before invalidating user style for the whole page. This keeps dynamic cosmetic hiding correct without refreshing blocker CSS for unrelated class and id mutations. Add text coverage for irrelevant class/id mutations that should preserve author style invalidation without refreshing blocker CSS. Also prove matching tokens still hide elements.
2026-05-23 17:28:30 -03:00
auto classes_bytes = classes_string.value().bytes_as_string_view();
auto ids_bytes = ids_string.value().bytes_as_string_view();
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
LibWeb: Refresh blocker CSS after relevant class/id changes Refresh content blocker styles when connected elements gain or change class or id tokens that can affect generic cosmetic selectors. Cache the class and id tokens covered by each document's content blocker stylesheet, then ask the adblock engine whether newly-added tokens can unlock selectors before invalidating user style for the whole page. This keeps dynamic cosmetic hiding correct without refreshing blocker CSS for unrelated class and id mutations. Add text coverage for irrelevant class/id mutations that should preserve author style invalidation without refreshing blocker CSS. Also prove matching tokens still hide elements.
2026-05-23 17:28:30 -03:00
return ContentBlocking::FFI::rust_content_blocker_has_generic_cosmetic_selectors(
m_engine,
reinterpret_cast<u8 const*>(url_string.characters()),
url_string.length(),
reinterpret_cast<u8 const*>(classes_bytes.characters_without_null_termination()),
classes_bytes.length(),
reinterpret_cast<u8 const*>(ids_bytes.characters_without_null_termination()),
ids_bytes.length());
LibWeb: Add cosmetic rules to ContentBlocker Split cosmetic blocker rules out from network patterns. Expose matching rules as user CSS through StyleScope. Invalidate affected user style caches when blocker state changes. Generated cosmetic CSS now respects disabled content blocking.
2026-05-21 13:35:29 -03:00
}
LibWeb: Thread request context into ContentBlocker Carry the initiating URL, fetch destination, initiator type, and request mode from Fetch into LoadRequest and pass them to ContentBlocker. The existing substring matcher still matches only the request URL, but the blocker API now receives the context needed by source-aware backends. Preserve that metadata for CORS preflights and connection hints, and add coverage for resource-type mapping and blob source URL normalization.
2026-05-21 11:44:02 -03:00
ContentBlocker::ResourceType ContentBlocker::resource_type_from_fetch_metadata(Optional<Fetch::Infrastructure::Request::Destination> const& destination, Optional<Fetch::Infrastructure::Request::InitiatorType> const& initiator_type, Fetch::Infrastructure::Request::Mode mode)
{
using Fetch::Infrastructure::Request;
if (mode == Request::Mode::WebSocket)
return ResourceType::WebSocket;
if (destination.has_value()) {
switch (*destination) {
case Request::Destination::Audio:
case Request::Destination::Track:
case Request::Destination::Video:
return ResourceType::Media;
case Request::Destination::Document:
return ResourceType::Document;
case Request::Destination::Embed:
case Request::Destination::Object:
return ResourceType::Object;
case Request::Destination::Font:
return ResourceType::Font;
case Request::Destination::Frame:
case Request::Destination::IFrame:
return ResourceType::Subdocument;
case Request::Destination::Image:
return ResourceType::Image;
case Request::Destination::AudioWorklet:
case Request::Destination::PaintWorklet:
case Request::Destination::Script:
case Request::Destination::ServiceWorker:
case Request::Destination::SharedWorker:
case Request::Destination::Worker:
return ResourceType::Script;
case Request::Destination::Style:
return ResourceType::Stylesheet;
case Request::Destination::JSON:
case Request::Destination::Manifest:
case Request::Destination::Report:
case Request::Destination::WebIdentity:
case Request::Destination::XSLT:
return ResourceType::Other;
}
VERIFY_NOT_REACHED();
}
if (initiator_type.has_value()) {
switch (*initiator_type) {
case Request::InitiatorType::Audio:
case Request::InitiatorType::Video:
case Request::InitiatorType::Track:
return ResourceType::Media;
case Request::InitiatorType::Beacon:
case Request::InitiatorType::Ping:
return ResourceType::Ping;
case Request::InitiatorType::Embed:
case Request::InitiatorType::Object:
return ResourceType::Object;
case Request::InitiatorType::Fetch:
case Request::InitiatorType::XMLHttpRequest:
return ResourceType::XMLHttpRequest;
case Request::InitiatorType::Font:
return ResourceType::Font;
case Request::InitiatorType::Frame:
case Request::InitiatorType::IFrame:
return ResourceType::Subdocument;
case Request::InitiatorType::Image:
case Request::InitiatorType::IMG:
return ResourceType::Image;
case Request::InitiatorType::Script:
return ResourceType::Script;
case Request::InitiatorType::CSS:
LibWeb: Use adblock-rust in ContentBlocker Replace the local substring matcher with the adblock-rust engine exposed through the dedicated content blocker Rust FFI. Keep the previous engine when a replacement list cannot be parsed. Pass shared list buffers directly into Rust instead of building a duplicate C++ vector of lines first. Generate cosmetic CSS through the Rust matcher, including generic class and id selectors collected from shadow-including descendants. Keep a supplemental index for generic cosmetic selector-list rules. adblock-rust indexes these rules under the first class or id token only, so also key them by later simple class and id selectors in the list. Update ContentBlocker coverage for rule options, exceptions, third-party checks, blob and file URLs, invalid list replacement, filtering toggles, cosmetic CSS, and generic selector-list cosmetics.
2026-05-23 17:15:37 -03:00
return ResourceType::Stylesheet;
LibWeb: Thread request context into ContentBlocker Carry the initiating URL, fetch destination, initiator type, and request mode from Fetch into LoadRequest and pass them to ContentBlocker. The existing substring matcher still matches only the request URL, but the blocker API now receives the context needed by source-aware backends. Preserve that metadata for CORS preflights and connection hints, and add coverage for resource-type mapping and blob source URL normalization.
2026-05-21 11:44:02 -03:00
case Request::InitiatorType::EarlyHint:
case Request::InitiatorType::Body:
case Request::InitiatorType::Input:
case Request::InitiatorType::Link:
case Request::InitiatorType::Other:
return ResourceType::Other;
}
VERIFY_NOT_REACHED();
}
return ResourceType::Other;
}
URL::URL ContentBlocker::source_url_for_matching(URL::URL const& source_url)
{
if (source_url.scheme() != "blob"sv)
return source_url;
auto parsed_url = URL::Parser::basic_parse(source_url.serialize_path());
if (!parsed_url.has_value())
return source_url;
return parsed_url.release_value();
}
LibWeb: Add a basic content filter (ad blocking!) :^) This patch adds a global (per-process) filter list to LibWeb that is used to filter all outgoing resource load requests. Basically we check the URL against a list of filter patterns and if it's a match for any one of them, we immediately fail the load. The filter list is a simple text file: ~/.config/BrowserContentFilters.txt It's one filter per line and they are simple glob filters for now, with implicit asterisks (*) at the start and end of the line.
2021-01-05 14:12:29 -03:00
}
Reference in a new issue Copy permalink