public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
* [rpms/chromium] f44: Fix FTBFS (patch from ungoogled chromium)
@ 2026-09-23 18:21 Than Ngo
0 siblings, 0 replies; only message in thread
From: Than Ngo @ 2026-09-23 18:21 UTC (permalink / raw)
To: git-commits
A new commit has been pushed.
Repo : rpms/chromium
Branch : f44
Commit : 096978acb1c3d82d1049e00d4dbf9f4457e6c817
Author : Than Ngo <than@redhat.com>
Date : 2026-09-23T20:17:43+02:00
Stats : +994/-153 in 3 file(s)
URL : https://src.fedoraproject.org/rpms/chromium/c/096978acb1c3d82d1049e00d4dbf9f4457e6c817?branch=f44
Log:
Fix FTBFS (patch from ungoogled chromium)
---
diff --git a/chromium-154-ftbfs-crubit.patch b/chromium-154-ftbfs-crubit.patch
index b4137f5..bcdedf3 100644
--- a/chromium-154-ftbfs-crubit.patch
+++ b/chromium-154-ftbfs-crubit.patch
@@ -1,169 +1,711 @@
-commit 493e6c3911e33cc356856bafbffc6cf95521266b
-Author: Dominik Röttsches <drott@chromium.org>
-Date: Thu Aug 13 08:42:15 2026 -0700
+ungoogle chromium patch from https://github.com/ungoogled-software/ungoogled-chromium/pull/3966
- Migrate OpenType format check bindings to Crubit
-
- We can remove the Box<> wrapped typing of FontFormatInfo along the way.
-
- DEPS checks for the generated output header files requires us to move
- the format_check target into the fonts subdirectory. This is a good
- opportunity to move more font specific build rules to the font subdir in
- the future and reduce the weight of the platform/BUILD.gn build dir.
-
- Exercise in using the Crubit bindings mechanism.
-
- No functional change.
-
- Change-Id: I9440c7285bb707b325b80ee074de51e714ee4884
- Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/8244248
- Reviewed-by: Łukasz Anforowicz <lukasza@chromium.org>
- Commit-Queue: Dominik Röttsches <drott@chromium.org>
- Cr-Commit-Position: refs/heads/main@{#1678858}
-
-diff --git a/third_party/blink/renderer/platform/BUILD.gn b/third_party/blink/renderer/platform/BUILD.gn
-index d5e81a3f07a3c..6a5d275460122 100644
---- a/third_party/blink/renderer/platform/BUILD.gn
-+++ b/third_party/blink/renderer/platform/BUILD.gn
-@@ -186,18 +186,6 @@ group("make_platform_generated") {
+--- a/components/cbor/BUILD.gn
++++ b/components/cbor/BUILD.gn
+@@ -12,7 +12,7 @@ buildflag_header("buildflags") {
+ # TODO(crbug.com/535682335): Remove `USE_CBOR_RUST` buildflag entirely,
+ # unconditionally enable Rust CBOR parser, and drop `is_cronet_build` check
+ # once Cronet supports Crubit dependencies.
+- flags = [ "USE_CBOR_RUST=!$is_cronet_build" ]
++ flags = [ "USE_CBOR_RUST=$enable_cpp_api_from_rust" ]
+ }
+
+ component("cbor") {
+@@ -35,7 +35,7 @@ component("cbor") {
+ "//base",
+ ]
+
+- if (!is_cronet_build) {
++ if (enable_cpp_api_from_rust) {
+ public_deps = [
+ "//build/rust/crubit",
+ "//components/cbor/rust:cbor_rust_bindings",
+@@ -62,7 +62,7 @@ source_set("unit_tests") {
+ "//testing/gtest",
+ "//third_party/fuzztest",
+ ]
+- if (!is_cronet_build) {
++ if (enable_cpp_api_from_rust) {
+ deps += [ "//components/cbor/rust:cbor_rust_unittests" ]
+ }
+
+--- a/components/web_package/BUILD.gn
++++ b/components/web_package/BUILD.gn
+@@ -40,7 +40,6 @@ static_library("web_package") {
+ "//base",
+ "//components/base32",
+ "//components/cbor",
+- "//components/web_package/signed_web_bundles/rust:signed_web_bundles_rust_bindings",
+ "//mojo/public/cpp/bindings",
+ "//net",
+ "//services/network/public/mojom",
+@@ -70,7 +69,6 @@ source_set("mojom_mapped_types") {
+
+ deps = [
+ "//base",
+- "//components/web_package/signed_web_bundles/rust:signed_web_bundles_rust_bindings",
+ "//crypto",
+ "//mojo/public/cpp/bindings",
]
+@@ -98,7 +96,6 @@ source_set("unit_tests") {
+ ":web_package",
+ "//base/test:test_support",
+ "//components/cbor",
+- "//components/web_package/signed_web_bundles/rust:signed_web_bundles_rust_unittests",
+ "//components/web_package/test_support",
+ "//mojo/public/cpp/bindings",
+ "//mojo/public/cpp/test_support:test_utils",
+--- a/components/web_package/signed_web_bundles/ecdsa_p256_sha256_signature.cc
++++ b/components/web_package/signed_web_bundles/ecdsa_p256_sha256_signature.cc
+@@ -9,7 +9,8 @@
+ #include "base/strings/stringprintf.h"
+ #include "base/types/expected.h"
+ #include "components/web_package/signed_web_bundles/ecdsa_p256_public_key.h"
+-#include "components/web_package/signed_web_bundles/rust/signed_web_bundles_rust.h"
++#include "crypto/keypair.h"
++#include "crypto/sign.h"
+
+ namespace web_package {
+
+@@ -50,8 +51,9 @@ EcdsaP256SHA256Signature::EcdsaP256SHA25
+ [[nodiscard]] bool EcdsaP256SHA256Signature::Verify(
+ base::span<const uint8_t> message,
+ const EcdsaP256PublicKey& public_key) const {
+- return signed_web_bundles::rust::verify_ecdsa_p256_signature(
+- public_key.bytes(), bytes(), message);
++ auto key = crypto::keypair::PublicKey::FromEcP256Point(public_key.bytes());
++ return crypto::sign::Verify(crypto::sign::ECDSA_SHA256, *key, message,
++ bytes());
}
--rust_static_library("font_format_check") {
-- allow_unsafe = true # Needed for FFI that underpins the `cxx` crate.
-- crate_root = "fonts/opentype/format_check.rs"
-- sources = [ crate_root ]
-- cxx_bindings = [ crate_root ]
-- deps = [
-- "//third_party/rust/font_types/v0_12:lib",
-- "//third_party/rust/read_fonts/v0_41:lib",
-- "//third_party/rust/skrifa/v0_44:lib",
-- ]
+ } // namespace web_package
+--- a/components/web_package/signed_web_bundles/ed25519_signature.cc
++++ b/components/web_package/signed_web_bundles/ed25519_signature.cc
+@@ -7,7 +7,6 @@
+ #include <algorithm>
+
+ #include "base/strings/stringprintf.h"
+-#include "components/web_package/signed_web_bundles/rust/signed_web_bundles_rust.h"
+ #include "third_party/boringssl/src/include/openssl/curve25519.h"
+
+ namespace web_package {
+@@ -43,8 +42,11 @@ Ed25519Signature::Ed25519Signature(std::
+ [[nodiscard]] bool Ed25519Signature::Verify(
+ base::span<const uint8_t> message,
+ const Ed25519PublicKey& public_key) const {
+- return signed_web_bundles::rust::verify_ed25519_signature(public_key.bytes(),
+- bytes(), message);
++ const std::array<uint8_t, ED25519_PUBLIC_KEY_LEN>& public_key_bytes =
++ public_key.bytes();
++ const std::array<uint8_t, ED25519_SIGNATURE_LEN>& signature_bytes = bytes();
++ return ED25519_verify(message.data(), message.size(), signature_bytes.data(),
++ public_key_bytes.data());
+ }
+
+ } // namespace web_package
+--- a/components/web_package/signed_web_bundles/integrity_block_parser.cc
++++ b/components/web_package/signed_web_bundles/integrity_block_parser.cc
+@@ -4,17 +4,19 @@
+
+ #include "components/web_package/signed_web_bundles/integrity_block_parser.h"
+
++#include <algorithm>
+ #include <string>
+-#include <string_view>
+ #include <vector>
+
+-#include "base/check.h"
+-#include "base/containers/span.h"
++#include "base/containers/map_util.h"
+ #include "base/functional/bind.h"
+ #include "base/strings/stringprintf.h"
++#include "base/strings/to_string.h"
+ #include "base/types/expected.h"
+ #include "base/types/expected_macros.h"
+ #include "components/cbor/reader.h"
++#include "components/cbor/writer.h"
++#include "components/web_package/mojom/web_bundle_parser.mojom-forward.h"
+ #include "components/web_package/mojom/web_bundle_parser.mojom.h"
+ #include "components/web_package/signed_web_bundles/constants.h"
+ #include "components/web_package/signed_web_bundles/ecdsa_p256_public_key.h"
+@@ -22,56 +24,11 @@
+ #include "components/web_package/signed_web_bundles/ed25519_public_key.h"
+ #include "components/web_package/signed_web_bundles/ed25519_signature.h"
+ #include "components/web_package/signed_web_bundles/integrity_block_attributes.h"
+-#include "components/web_package/signed_web_bundles/rust/signed_web_bundles_rust.h"
+ #include "components/web_package/signed_web_bundles/signed_web_bundle_id.h"
+ #include "components/web_package/signed_web_bundles/types.h"
+
+ namespace web_package {
+
+-namespace {
+-
+-using SignatureType = signed_web_bundles::rust::SignatureType::Tag;
+-using signed_web_bundles::rust::parse_integrity_block;
+-
+-base::expected<mojom::BundleIntegrityBlockSignatureStackEntryPtr, std::string>
+-CreateSignatureStackEntry(
+- const signed_web_bundles::rust::SignatureStackEntry& entry) {
+- auto parsed_sig = mojom::BundleIntegrityBlockSignatureStackEntry::New();
+-
+- switch (entry.signature_type.tag) {
+- case SignatureType::Ed25519: {
+- ASSIGN_OR_RETURN(auto public_key,
+- Ed25519PublicKey::Create(entry.public_key.to_span()));
+- ASSIGN_OR_RETURN(auto signature,
+- Ed25519Signature::Create(entry.signature.to_span()));
+- parsed_sig->signature_info = mojom::SignatureInfo::NewEd25519(
+- mojom::SignatureInfoEd25519::New(public_key, signature));
+- break;
+- }
+- case SignatureType::EcdsaP256SHA256: {
+- ASSIGN_OR_RETURN(auto public_key,
+- EcdsaP256PublicKey::Create(entry.public_key.to_span()));
+- ASSIGN_OR_RETURN(auto signature, EcdsaP256SHA256Signature::Create(
+- entry.signature.to_span()));
+- parsed_sig->signature_info = mojom::SignatureInfo::NewEcdsaP256Sha256(
+- mojom::SignatureInfoEcdsaP256SHA256::New(public_key, signature));
+- break;
+- }
+- case SignatureType::Unknown: {
+- parsed_sig->signature_info =
+- mojom::SignatureInfo::NewUnknown(mojom::SignatureInfoUnknown::New());
+- break;
+- }
+- }
+-
+- parsed_sig->attributes_cbor =
+- BinaryData(entry.attributes_cbor.begin(), entry.attributes_cbor.end());
+-
+- return parsed_sig;
-}
-
+-} // namespace
+-
+ IntegrityBlockParser::IntegrityBlockParser(
+ mojom::BundleDataSource& data_source,
+ WebBundleParser::ParseIntegrityBlockCallback callback)
+@@ -103,37 +60,103 @@ void IntegrityBlockParser::OnIntegrityBl
+ RunErrorCallback("Error reading the integrity block.");
+ return;
+ }
++ // This structure is built during parsing and returned by the final callback
++ mojom::BundleIntegrityBlockPtr integrity_block =
++ mojom::BundleIntegrityBlock::New();
++
++ size_t consumed_bytes = 0;
++ cbor::Reader::DecoderError error;
++ cbor::Reader::Config config;
++ config.num_bytes_consumed = &consumed_bytes;
++ config.error_code_out = &error;
++
++ // When config `bytes_consumed` are assigned the CBOR parser reads only to the
++ // end of a structure. It parses only Integrity Block even if Web Bundle part
++ // starts just after.
++ std::optional<cbor::Value> value = cbor::Reader::Read(*data, config);
++ if (!value) {
++ RunErrorCallback("Error parsing integrity block as CBOR: " +
++ std::string(cbor::Reader::ErrorCodeToString(error)));
++ return;
++ }
++ integrity_block->size = consumed_bytes;
++
++ if (!value->is_array()) {
++ RunErrorCallback("Integrity block is not a CBOR array.");
++ return;
++ }
+
+- const auto parse_res = parse_integrity_block(*data);
+- if (!parse_res.has_value()) {
+- const auto& error = parse_res.error();
+- RunErrorCallback(std::string(error.message.as_str()),
+- error.is_version_error
+- ? mojom::BundleParseErrorType::kVersionError
+- : mojom::BundleParseErrorType::kFormatError);
++ const cbor::Value::ArrayValue& top_array = value->GetArray();
++ if (top_array.size() != kIntegrityBlockV2TopLevelArrayLength) {
++ RunErrorCallback(base::StringPrintf(
++ "Invalid integrity block array length: expected %u, got %zu.",
++ kIntegrityBlockV2TopLevelArrayLength, top_array.size()));
+ return;
+ }
+
+- const auto& parsed_ib = *parse_res;
+- auto integrity_block = mojom::BundleIntegrityBlock::New();
+- integrity_block->size = parsed_ib.size;
+-
+- const std::string_view web_bundle_id_str =
+- parsed_ib.web_bundle_id.to_string_view();
+- RETURN_IF_ERROR(
+- SignedWebBundleId::Create(web_bundle_id_str),
+- [&](std::string error) { RunErrorCallback(std::move(error)); });
+-
+- integrity_block->attributes =
+- IntegrityBlockAttributes(std::string(web_bundle_id_str),
+- BinaryData(parsed_ib.attributes_cbor.begin(),
+- parsed_ib.attributes_cbor.end()));
++ // 1. Magic bytes
++ if (!top_array[0].is_bytestring() ||
++ !std::ranges::equal(top_array[0].GetBytestring(),
++ kIntegrityBlockMagicBytes)) {
++ RunErrorCallback("Unexpected magic bytes.");
++ return;
++ }
++
++ // 2. Version
++ if (!top_array[1].is_bytestring() ||
++ !std::ranges::equal(top_array[1].GetBytestring(),
++ kIntegrityBlockV2VersionBytes)) {
++ RunErrorCallback("Unexpected version bytes.",
++ mojom::BundleParseErrorType::kVersionError);
++ return;
++ }
+
+- for (const auto& entry : parsed_ib.signature_stack) {
++ // 3. Attributes
++ if (!top_array[2].is_map()) {
++ RunErrorCallback("Integrity block attributes must be a map.");
++ return;
++ }
++ const cbor::Value::MapValue& attributes_map = top_array[2].GetMap();
++ const cbor::Value* web_bundle_id =
++ base::FindOrNull(attributes_map, cbor::Value(kWebBundleIdAttributeName));
++ if (!web_bundle_id || !web_bundle_id->is_string()) {
++ RunErrorCallback(
++ "`webBundleId` integrity block attribute is missing or malformed.");
++ return;
++ }
++
++ // Check if web_bundle_id is correct
++ RETURN_IF_ERROR(SignedWebBundleId::Create(web_bundle_id->GetString()),
++ [&](const std::string& error) { RunErrorCallback(error); });
++
++ BinaryData attributes_cbor = *cbor::Writer::Write(top_array[2]);
++ integrity_block->attributes = IntegrityBlockAttributes(
++ web_bundle_id->GetString(), std::move(attributes_cbor));
++
++ // 4. Signature Stack
++ if (!top_array[3].is_array()) {
++ RunErrorCallback("Signature stack must be an array.");
++ return;
++ }
++ const cbor::Value::ArrayValue& signatures = top_array[3].GetArray();
++ if (signatures.empty()) {
++ RunErrorCallback(
++ "The signature stack must contain at least one signature.");
++ return;
++ }
++
++ for (const auto& signature_info_raw : signatures) {
+ ASSIGN_OR_RETURN(
+- auto parsed_sig, CreateSignatureStackEntry(entry),
+- [&](std::string error) { RunErrorCallback(std::move(error)); });
+- integrity_block->signature_stack.push_back(std::move(parsed_sig));
++ auto parsed_signature_info, ParseSignatureInfo(signature_info_raw),
++ [&](const std::string& error) { this->RunErrorCallback(error); });
++
++ if (integrity_block->signature_stack.empty() &&
++ parsed_signature_info->signature_info->is_unknown()) {
++ RunErrorCallback("Unknown cipher type of the first signature.");
++ return;
++ }
++ integrity_block->signature_stack.push_back(
++ std::move(parsed_signature_info));
+ }
+
+ std::move(complete_callback_)
+@@ -141,13 +164,74 @@ void IntegrityBlockParser::OnIntegrityBl
+ std::move(integrity_block), nullptr));
+ }
+
++base::expected<mojom::BundleIntegrityBlockSignatureStackEntryPtr, std::string>
++IntegrityBlockParser::ParseSignatureInfo(
++ const cbor::Value& signature_info_raw) {
++ if (!signature_info_raw.is_array() ||
++ signature_info_raw.GetArray().size() != 2) {
++ return base::unexpected(
++ "Each signature stack entry must contain exactly two elements.");
++ }
++
++ const cbor::Value::ArrayValue& signature_info_array =
++ signature_info_raw.GetArray();
++ if (!signature_info_array[0].is_map() ||
++ !signature_info_array[1].is_bytestring()) {
++ return base::unexpected("Malformed signature stack entry.");
++ }
++
++ mojom::BundleIntegrityBlockSignatureStackEntryPtr parsed_signature_info =
++ mojom::BundleIntegrityBlockSignatureStackEntry::New();
++ parsed_signature_info->attributes_cbor =
++ *cbor::Writer::Write(signature_info_array[0]);
++
++ const cbor::Value::MapValue& signature_attributes =
++ signature_info_array[0].GetMap();
++ const BinaryData& signature_bytes = signature_info_array[1].GetBytestring();
++
++ const cbor::Value* ed25519_key = base::FindOrNull(
++ signature_attributes, cbor::Value(kEd25519PublicKeyAttributeName));
++ const cbor::Value* ecdsa_key = base::FindOrNull(
++ signature_attributes, cbor::Value(kEcdsaP256PublicKeyAttributeName));
++
++ if (ed25519_key && ecdsa_key) {
++ return base::unexpected("Multiple key types for one signature.");
++ } else if (ed25519_key && !ed25519_key->is_bytestring()) {
++ return base::unexpected("Invalid ED25519 key.");
++ } else if (ecdsa_key && !ecdsa_key->is_bytestring()) {
++ return base::unexpected("Invalid ECDSA key.");
++
++ } else if (ed25519_key && ed25519_key->is_bytestring()) {
++ ASSIGN_OR_RETURN(auto public_key,
++ Ed25519PublicKey::Create(ed25519_key->GetBytestring()));
++ ASSIGN_OR_RETURN(auto signature, Ed25519Signature::Create(signature_bytes));
++ parsed_signature_info->signature_info = mojom::SignatureInfo::NewEd25519(
++ mojom::SignatureInfoEd25519::New(public_key, signature));
++
++ } else if (ecdsa_key && ecdsa_key->is_bytestring()) {
++ ASSIGN_OR_RETURN(auto public_key,
++ EcdsaP256PublicKey::Create(ecdsa_key->GetBytestring()));
++ ASSIGN_OR_RETURN(auto signature,
++ EcdsaP256SHA256Signature::Create(signature_bytes));
++ parsed_signature_info->signature_info =
++ mojom::SignatureInfo::NewEcdsaP256Sha256(
++ mojom::SignatureInfoEcdsaP256SHA256::New(public_key, signature));
++
++ } else {
++ parsed_signature_info->signature_info =
++ mojom::SignatureInfo::NewUnknown(mojom::SignatureInfoUnknown::New());
++ }
++
++ return parsed_signature_info;
++}
++
+ void IntegrityBlockParser::RunErrorCallback(
+- std::string message,
++ const std::string& message,
+ mojom::BundleParseErrorType error_type) {
+ std::move(complete_callback_)
+- .Run(base::BindOnce(std::move(result_callback_), nullptr,
+- mojom::BundleIntegrityBlockParseError::New(
+- error_type, std::move(message))));
++ .Run(base::BindOnce(
++ std::move(result_callback_), nullptr,
++ mojom::BundleIntegrityBlockParseError::New(error_type, message)));
+ }
+
+ } // namespace web_package
+--- a/components/web_package/signed_web_bundles/integrity_block_parser.h
++++ b/components/web_package/signed_web_bundles/integrity_block_parser.h
+@@ -5,13 +5,8 @@
+ #ifndef COMPONENTS_WEB_PACKAGE_SIGNED_WEB_BUNDLES_INTEGRITY_BLOCK_PARSER_H_
+ #define COMPONENTS_WEB_PACKAGE_SIGNED_WEB_BUNDLES_INTEGRITY_BLOCK_PARSER_H_
+
+-#include <optional>
+-#include <string>
+-
+-#include "base/compiler_specific.h"
+-#include "base/memory/raw_ref.h"
+-#include "base/memory/weak_ptr.h"
+ #include "components/web_package/mojom/web_bundle_parser.mojom-forward.h"
++#include "components/web_package/signed_web_bundles/integrity_block_attributes.h"
+ #include "components/web_package/signed_web_bundles/types.h"
+ #include "components/web_package/web_bundle_parser.h"
+
+@@ -20,7 +15,7 @@ namespace web_package {
+ class IntegrityBlockParser : public WebBundleParser::WebBundleSectionParser {
+ public:
+ explicit IntegrityBlockParser(
+- mojom::BundleDataSource& data_source LIFETIME_BOUND,
++ mojom::BundleDataSource& data_source,
+ WebBundleParser::ParseIntegrityBlockCallback callback);
+
+ IntegrityBlockParser(const IntegrityBlockParser&) = delete;
+@@ -35,7 +30,10 @@ class IntegrityBlockParser : public WebB
+ private:
+ void OnIntegrityBlockRead(const std::optional<BinaryData>& data);
+
+- void RunErrorCallback(std::string message,
++ base::expected<mojom::BundleIntegrityBlockSignatureStackEntryPtr, std::string>
++ ParseSignatureInfo(const cbor::Value& attributes_map);
++
++ void RunErrorCallback(const std::string& message,
+ mojom::BundleParseErrorType error_type =
+ mojom::BundleParseErrorType::kFormatError);
+
+--- a/components/web_package/signed_web_bundles/rust/BUILD.gn
++++ b/components/web_package/signed_web_bundles/rust/BUILD.gn
+@@ -10,7 +10,6 @@ rust_static_library("signed_web_bundles_
+ sources = [
+ "constants.rs",
+ "integrity_block.rs",
+- "signature_verifier.rs",
+ "types.rs",
+ crate_root,
+ ]
+--- a/components/web_package/signed_web_bundles/signed_web_bundle_signature_verifier.cc
++++ b/components/web_package/signed_web_bundles/signed_web_bundle_signature_verifier.cc
+@@ -20,14 +20,17 @@
+ #include "base/task/thread_pool.h"
+ #include "base/types/expected.h"
+ #include "base/types/expected_macros.h"
++#include "components/cbor/values.h"
++#include "components/cbor/writer.h"
++#include "components/web_package/signed_web_bundles/constants.h"
+ #include "components/web_package/signed_web_bundles/identity_validator.h"
+ #include "components/web_package/signed_web_bundles/integrity_block_parser.h"
+-#include "components/web_package/signed_web_bundles/rust/signed_web_bundles_rust.h"
+ #include "components/web_package/signed_web_bundles/signed_web_bundle_id.h"
+ #include "components/web_package/signed_web_bundles/signed_web_bundle_integrity_block.h"
+ #include "components/web_package/signed_web_bundles/signed_web_bundle_signature_stack.h"
+ #include "components/web_package/signed_web_bundles/signed_web_bundle_signature_stack_entry.h"
+ #include "components/web_package/signed_web_bundles/signed_web_bundle_utils.h"
++#include "crypto/hash.h"
+ #include "third_party/abseil-cpp/absl/functional/overload.h"
+ #include "third_party/boringssl/src/include/openssl/sha.h"
+
+@@ -37,10 +40,32 @@ namespace {
+
+ std::vector<uint8_t> CreateIntegrityBlockCbor(
+ const SignedWebBundleIntegrityBlock& integrity_block) {
+- auto ib_cbor_rust =
+- signed_web_bundles::rust::create_empty_integrity_block_cbor(
+- integrity_block.attributes_cbor());
+- return std::vector<uint8_t>(ib_cbor_rust.begin(), ib_cbor_rust.end());
++ // This function looks like it should use a cbor::Value::ArrayValue to build
++ // the outer array, but it can't: one of the elements is a pre-encoded CBOR
++ // value which we can't safely decode because it's untrusted input. This is
++ // obviously undesirable, because there's no guarantee at all that the
++ // pre-encoded value is actually valid CBOR.
++ //
++ // TODO(https://crbug.com/454485901): once there's a memory-safe CBOR parser,
++ // re-parse the pre-encoded value, then re-encode it here instead of
++ // constructing a CBOR array by hand so that we're guaranteed that the result
++ // of this function is valid.
++ std::vector<uint8_t> ib_cbor;
++
++ // 0x84 is the encoding byte for an array of length 4.
++ ib_cbor.push_back(0x84);
++ base::Extend(ib_cbor,
++ *cbor::Writer::Write(cbor::Value(kIntegrityBlockMagicBytes)));
++ base::Extend(ib_cbor, *cbor::Writer::Write(
++ cbor::Value(kIntegrityBlockV2VersionBytes)));
++ // We cannot parse `attributes().cbor()` back to a cbor::Value as they
++ // technically represent untrusted input.
++ base::Extend(ib_cbor, integrity_block.attributes_cbor());
++ // Encode an empty signature array.
++ base::Extend(ib_cbor,
++ *cbor::Writer::Write(cbor::Value(cbor::Value::ArrayValue())));
++
++ return ib_cbor;
+ }
+
+ base::expected<void, SignedWebBundleSignatureVerifier::Error>
+@@ -104,7 +129,7 @@ SignedWebBundleSignatureVerifier::Calcul
+ return base::unexpected(base::File::ErrorToString(file.GetLastFileError()));
+ }
+
+- signed_web_bundles::rust::Sha512Hasher hasher;
++ crypto::hash::Hasher hash(crypto::hash::kSha512);
+
+ // Calculate the hash of the Signed Web Bundle excluding its integrity block.
+ // The file might be too big to read it into memory all at once, which is why
+@@ -121,14 +146,15 @@ SignedWebBundleSignatureVerifier::Calcul
+ base::File::ErrorToString(file.GetLastFileError()));
+ }
+ data.resize(*bytes_read);
+- hasher.update(data);
++ hash.Update(data);
+
+ if (!base::CheckAdd(offset, *bytes_read).AssignIfValid(&offset)) {
+ return base::unexpected("The Signed Web Bundle is too large.");
+ }
+ }
+
+- SHA512Digest digest = std::move(hasher).finish();
++ SHA512Digest digest;
++ hash.Finish(digest);
+ return digest;
+ }
+
+--- a/components/web_package/signed_web_bundles/signed_web_bundle_utils.cc
++++ b/components/web_package/signed_web_bundles/signed_web_bundle_utils.cc
+@@ -5,18 +5,37 @@
+ #include "components/web_package/signed_web_bundles/signed_web_bundle_utils.h"
+
+ #include <cstdint>
+-#include <vector>
+
+-#include "components/web_package/signed_web_bundles/rust/signed_web_bundles_rust.h"
++#include "base/containers/extend.h"
++#include "base/containers/span.h"
++#include "base/containers/span_writer.h"
+
+ namespace web_package {
+
++namespace {
++
++void AddItemToPayload(std::vector<uint8_t>& payload,
++ base::span<const uint8_t> item) {
++ // Each item that is part of the payload is prefixed with its length encoded
++ // as a 64 bit unsigned integer.
++ std::array<uint8_t, sizeof(uint64_t)> length;
++ auto writer = base::SpanWriter(base::span(length));
++ CHECK(writer.WriteU64BigEndian(item.size()));
++
++ base::Extend(payload, base::span(length));
++ base::Extend(payload, item);
++}
++
++} // namespace
++
+ std::vector<uint8_t> CreateSignaturePayload(
+ const SignedWebBundleSignatureData& data) {
+- auto payload_rust = signed_web_bundles::rust::create_signature_payload(
+- data.unsigned_web_bundle_hash, data.integrity_block_cbor,
+- data.attributes_cbor);
+- return std::vector<uint8_t>(payload_rust.begin(), payload_rust.end());
++ std::vector<uint8_t> payload;
++ AddItemToPayload(payload, data.unsigned_web_bundle_hash);
++ AddItemToPayload(payload, data.integrity_block_cbor);
++ AddItemToPayload(payload, data.attributes_cbor);
++
++ return payload;
+ }
+
+ } // namespace web_package
+--- a/third_party/blink/renderer/platform/BUILD.gn
++++ b/third_party/blink/renderer/platform/BUILD.gn
+@@ -186,6 +186,18 @@ group("make_platform_generated") {
+ ]
+ }
+
++rust_static_library("font_format_check") {
++ allow_unsafe = true # Needed for FFI that underpins the `cxx` crate.
++ crate_root = "fonts/opentype/format_check.rs"
++ sources = [ crate_root ]
++ cxx_bindings = [ crate_root ]
++ deps = [
++ "//third_party/rust/font_types/v0_12:lib",
++ "//third_party/rust/read_fonts/v0_43:lib",
++ "//third_party/rust/skrifa/v0_46:lib",
++ ]
++}
++
rust_static_library("rustfft_ffi") {
allow_unsafe = true # Needed for FFI that underpins the `cxx` crate.
crate_root = "audio/rustfft_ffi.rs"
-@@ -1806,6 +1794,7 @@ component("platform") {
+@@ -1792,7 +1804,6 @@ component("platform") {
":allow_discouraged_type",
":blink_platform_public_deps",
":platform_export",
-+ "//build/rust/crubit",
+- "//build/rust/crubit",
"//gpu/command_buffer/client:raster_interface",
"//media/capture:capture_lib",
"//mojo/public/cpp/base",
-@@ -1832,8 +1821,8 @@ component("platform") {
+@@ -1819,8 +1830,8 @@ component("platform") {
"//ui/native_theme/features",
]
deps = [
-- ":font_format_check",
++ ":font_format_check",
":rustfft_ffi",
-+ "fonts:font_format_bindings",
+- "fonts:font_format_bindings",
"//base:base_static",
"//base/allocator:buildflags",
"//build:chromecast_buildflags",
-diff --git a/third_party/blink/renderer/platform/fonts/BUILD.gn b/third_party/blink/renderer/platform/fonts/BUILD.gn
-new file mode 100644
-index 0000000000000..51b9b03ba7c85
---- /dev/null
-+++ b/third_party/blink/renderer/platform/fonts/BUILD.gn
-@@ -0,0 +1,19 @@
-+# Copyright 2026 The Chromium Authors
-+# Use of this source code is governed by a BSD-style license that can be
-+# found in the LICENSE file.
-+
-+import("//build/rust/rust_static_library.gni")
-+
-+rust_static_library("font_format") {
-+ crate_root = "opentype/format_check.rs"
-+ sources = [ crate_root ]
-+ cpp_api_from_rust = {
-+ target_name = "font_format_bindings"
-+ cpp_namespace = "font_format"
-+ }
-+ deps = [
-+ "//third_party/rust/font_types/v0_12:lib",
-+ "//third_party/rust/read_fonts/v0_43:lib",
-+ "//third_party/rust/skrifa/v0_46:lib",
-+ ]
-+}
-diff --git a/third_party/blink/renderer/platform/fonts/opentype/font_format_check.cc b/third_party/blink/renderer/platform/fonts/opentype/font_format_check.cc
-index b9d2639822bc0..f58e9433d39f4 100644
+--- a/third_party/blink/renderer/platform/fonts/BUILD.gn
++++ /dev/null
+@@ -1,19 +0,0 @@
+-# Copyright 2026 The Chromium Authors
+-# Use of this source code is governed by a BSD-style license that can be
+-# found in the LICENSE file.
+-
+-import("//build/rust/rust_static_library.gni")
+-
+-rust_static_library("font_format") {
+- crate_root = "opentype/format_check.rs"
+- sources = [ crate_root ]
+- cpp_api_from_rust = {
+- target_name = "font_format_bindings"
+- cpp_namespace = "font_format"
+- }
+- deps = [
+- "//third_party/rust/font_types/v0_12:lib",
+- "//third_party/rust/read_fonts/v0_43:lib",
+- "//third_party/rust/skrifa/v0_46:lib",
+- ]
+-}
--- a/third_party/blink/renderer/platform/fonts/opentype/font_format_check.cc
+++ b/third_party/blink/renderer/platform/fonts/opentype/font_format_check.cc
-@@ -7,7 +7,6 @@
+@@ -7,6 +7,7 @@
#include "base/containers/span.h"
#include "base/containers/span_rust.h"
#include "base/numerics/byte_conversions.h"
--#include "third_party/blink/renderer/platform/fonts/opentype/format_check.rs.h"
++#include "third_party/blink/renderer/platform/fonts/opentype/format_check.rs.h"
#include "third_party/blink/renderer/platform/runtime_enabled_features.h"
#include "third_party/blink/renderer/platform/wtf/vector.h"
#include "third_party/skia/include/core/SkTypeface.h"
-@@ -15,35 +14,37 @@
+@@ -14,37 +15,35 @@
namespace blink {
FontFormatCheck::FontFormatCheck(sk_sp<SkData> sk_data)
-- : format_info_(font_format_check::get_font_format_info(
-+ : format_info_(font_format::get_font_format_info(
+- : format_info_(font_format::get_font_format_info(
++ : format_info_(font_format_check::get_font_format_info(
base::SpanToRustSlice(sk_data->byteSpan()))) {}
-+FontFormatCheck::~FontFormatCheck() = default;
-+
+-FontFormatCheck::~FontFormatCheck() = default;
+-
bool FontFormatCheck::IsVariableFont() const {
-- return font_format_check::is_variable(*format_info_);
-+ return font_format::is_variable(format_info_);
+- return font_format::is_variable(format_info_);
++ return font_format_check::is_variable(*format_info_);
}
bool FontFormatCheck::IsCbdtCblcColorFont() const {
-- return font_format_check::is_cbdt_cblc(*format_info_);
-+ return font_format::is_cbdt_cblc(format_info_);
+- return font_format::is_cbdt_cblc(format_info_);
++ return font_format_check::is_cbdt_cblc(*format_info_);
}
bool FontFormatCheck::IsEbdtEblcMonochromeFont() const {
-- return font_format_check::is_ebdt_eblc(*format_info_);
-+ return font_format::is_ebdt_eblc(format_info_);
+- return font_format::is_ebdt_eblc(format_info_);
++ return font_format_check::is_ebdt_eblc(*format_info_);
}
bool FontFormatCheck::IsColrCpalColorFontV0() const {
-- return font_format_check::is_colrv0(*format_info_);
-+ return font_format::is_colrv0(format_info_);
+- return font_format::is_colrv0(format_info_);
++ return font_format_check::is_colrv0(*format_info_);
}
bool FontFormatCheck::IsColrCpalColorFontV1() const {
-- return font_format_check::is_colrv1(*format_info_);
-+ return font_format::is_colrv1(format_info_);
+- return font_format::is_colrv1(format_info_);
++ return font_format_check::is_colrv1(*format_info_);
}
bool FontFormatCheck::IsSbixColorFont() const {
-- return font_format_check::is_sbix(*format_info_);
-+ return font_format::is_sbix(format_info_);
+- return font_format::is_sbix(format_info_);
++ return font_format_check::is_sbix(*format_info_);
}
bool FontFormatCheck::IsCff2OutlineFont() const {
-- return font_format_check::is_cff2(*format_info_);
-+ return font_format::is_cff2(format_info_);
+- return font_format::is_cff2(format_info_);
++ return font_format_check::is_cff2(*format_info_);
}
bool FontFormatCheck::IsVariableColrV0Font() const {
-@@ -57,7 +58,7 @@ bool FontFormatCheck::IsColorFont() const {
+@@ -58,7 +57,7 @@ bool FontFormatCheck::IsColorFont() cons
bool FontFormatCheck::IsAvar2Font() const {
return RuntimeEnabledFeatures::FontFormatAvar2Enabled() &&
-- font_format_check::is_avar2(*format_info_);
-+ font_format::is_avar2(format_info_);
+- font_format::is_avar2(format_info_);
++ font_format_check::is_avar2(*format_info_);
}
FontFormatCheck::VariableFontSubType FontFormatCheck::ProbeVariableFont(
-diff --git a/third_party/blink/renderer/platform/fonts/opentype/font_format_check.h b/third_party/blink/renderer/platform/fonts/opentype/font_format_check.h
-index 19d2639233b07..af50dbdf74d00 100644
--- a/third_party/blink/renderer/platform/fonts/opentype/font_format_check.h
+++ b/third_party/blink/renderer/platform/fonts/opentype/font_format_check.h
@@ -5,7 +5,7 @@
#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_FONTS_OPENTYPE_FONT_FORMAT_CHECK_H_
#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_FONTS_OPENTYPE_FONT_FORMAT_CHECK_H_
--#include "third_party/blink/renderer/platform/fonts/opentype/format_check.rs.h"
-+#include "third_party/blink/renderer/platform/fonts/font_format.h"
+-#include "third_party/blink/renderer/platform/fonts/font_format.h"
++#include "third_party/blink/renderer/platform/fonts/opentype/format_check.rs.h"
#include "third_party/blink/renderer/platform/platform_export.h"
#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
#include "third_party/skia/include/core/SkData.h"
@@ -171,8 +713,8 @@ index 19d2639233b07..af50dbdf74d00 100644
public:
explicit FontFormatCheck(sk_sp<SkData>);
-- virtual ~FontFormatCheck() = default;
-+ virtual ~FontFormatCheck();
+- virtual ~FontFormatCheck();
++ virtual ~FontFormatCheck() = default;
virtual bool IsVariableFont() const;
virtual bool IsCbdtCblcColorFont() const;
virtual bool IsEbdtEblcMonochromeFont() const;
@@ -180,103 +722,101 @@ index 19d2639233b07..af50dbdf74d00 100644
enum class COLRVersion { kCOLRV0, kCOLRV1, kNoCOLR };
private:
-- rust::Box<font_format_check::FontFormatInfo> format_info_;
-+ font_format::FontFormatInfo format_info_;
+- font_format::FontFormatInfo format_info_;
++ rust::Box<font_format_check::FontFormatInfo> format_info_;
};
} // namespace blink
-diff --git a/third_party/blink/renderer/platform/fonts/opentype/format_check.rs b/third_party/blink/renderer/platform/fonts/opentype/format_check.rs
-index eda8e6b2b8188..b99f0ec8655e6 100644
--- a/third_party/blink/renderer/platform/fonts/opentype/format_check.rs
+++ b/third_party/blink/renderer/platform/fonts/opentype/format_check.rs
@@ -23,7 +23,7 @@ pub struct FontFormatInfo {
format_flags: Option<FontFormatFlags>,
}
--pub fn get_font_format_info(font_bytes: &[u8]) -> Box<FontFormatInfo> {
-+pub fn get_font_format_info(font_bytes: &[u8]) -> FontFormatInfo {
+-pub fn get_font_format_info(font_bytes: &[u8]) -> FontFormatInfo {
++pub fn get_font_format_info(font_bytes: &[u8]) -> Box<FontFormatInfo> {
let file_ref = make_font_ref_internal(font_bytes, 0);
match file_ref {
-@@ -32,11 +32,11 @@ pub fn get_font_format_info(font_bytes: &[u8]) -> Box<FontFormatInfo> {
+@@ -32,11 +32,11 @@ pub fn get_font_format_info(font_bytes:
font.table_directory().table_records().iter().map(|e| e.tag()).collect();
let color_version = get_colr_version(&font);
let avar_version = get_avar_version(&font);
-- Box::new(FontFormatInfo {
-+ FontFormatInfo {
+- FontFormatInfo {
++ Box::new(FontFormatInfo {
format_flags: Some(FontFormatFlags { table_tags, color_version, avar_version }),
-- })
-+ }
+- }
++ })
}
-- _ => Box::new(FontFormatInfo::default()),
-+ _ => FontFormatInfo::default(),
+- _ => FontFormatInfo::default(),
++ _ => Box::new(FontFormatInfo::default()),
}
}
-@@ -44,10 +44,10 @@ fn get_colr_version(font_ref: &FontRef) -> Option<u16> {
+@@ -44,10 +44,10 @@ fn get_colr_version(font_ref: &FontRef)
Some(font_ref.colr().ok()?.version())
}
--fn is_colrv1(format_info: &FontFormatInfo) -> bool {
-+pub fn is_colrv1(format_info: &FontFormatInfo) -> bool {
+-pub fn is_colrv1(format_info: &FontFormatInfo) -> bool {
++fn is_colrv1(format_info: &FontFormatInfo) -> bool {
matches!(&format_info.format_flags, Some(FontFormatFlags { color_version: Some(1), .. }),)
}
--fn is_colrv0(format_info: &FontFormatInfo) -> bool {
-+pub fn is_colrv0(format_info: &FontFormatInfo) -> bool {
+-pub fn is_colrv0(format_info: &FontFormatInfo) -> bool {
++fn is_colrv0(format_info: &FontFormatInfo) -> bool {
matches!(&format_info.format_flags, Some(FontFormatFlags { color_version: Some(0), .. }),)
}
-@@ -56,7 +56,7 @@ fn get_avar_version(font_ref: &FontRef) -> Option<(u16, u16)> {
+@@ -56,7 +56,7 @@ fn get_avar_version(font_ref: &FontRef)
Some((version.major, version.minor))
}
--fn is_avar2(format_info: &FontFormatInfo) -> bool {
-+pub fn is_avar2(format_info: &FontFormatInfo) -> bool {
+-pub fn is_avar2(format_info: &FontFormatInfo) -> bool {
++fn is_avar2(format_info: &FontFormatInfo) -> bool {
matches!(&format_info.format_flags, Some(FontFormatFlags { avar_version: Some((2, _)), .. }),)
}
-@@ -69,39 +69,22 @@ fn has_tags(format_info: &FontFormatInfo, query: &[Tag]) -> bool {
+@@ -69,22 +69,39 @@ fn has_tags(format_info: &FontFormatInfo
}
}
--fn is_variable(format_info: &FontFormatInfo) -> bool {
-+pub fn is_variable(format_info: &FontFormatInfo) -> bool {
+-pub fn is_variable(format_info: &FontFormatInfo) -> bool {
++fn is_variable(format_info: &FontFormatInfo) -> bool {
has_tags(format_info, &[Tag::new(b"fvar")])
}
--fn is_sbix(format_info: &FontFormatInfo) -> bool {
-+pub fn is_sbix(format_info: &FontFormatInfo) -> bool {
+-pub fn is_sbix(format_info: &FontFormatInfo) -> bool {
++fn is_sbix(format_info: &FontFormatInfo) -> bool {
has_tags(format_info, &[Tag::new(b"sbix")])
}
--fn is_cbdt_cblc(format_info: &FontFormatInfo) -> bool {
-+pub fn is_cbdt_cblc(format_info: &FontFormatInfo) -> bool {
+-pub fn is_cbdt_cblc(format_info: &FontFormatInfo) -> bool {
++fn is_cbdt_cblc(format_info: &FontFormatInfo) -> bool {
has_tags(format_info, &[Tag::new(b"CBDT"), Tag::new(b"CBLC")])
}
--fn is_ebdt_eblc(format_info: &FontFormatInfo) -> bool {
-+pub fn is_ebdt_eblc(format_info: &FontFormatInfo) -> bool {
+-pub fn is_ebdt_eblc(format_info: &FontFormatInfo) -> bool {
++fn is_ebdt_eblc(format_info: &FontFormatInfo) -> bool {
has_tags(format_info, &[Tag::new(b"EBDT"), Tag::new(b"EBLC")])
}
--fn is_cff2(format_info: &FontFormatInfo) -> bool {
-+pub fn is_cff2(format_info: &FontFormatInfo) -> bool {
+-pub fn is_cff2(format_info: &FontFormatInfo) -> bool {
++fn is_cff2(format_info: &FontFormatInfo) -> bool {
has_tags(format_info, &[Tag::new(b"CFF2")])
}
--
--#[cxx::bridge(namespace = "font_format_check")]
--pub mod ffi {
-- extern "Rust" {
-- type FontFormatInfo;
--
-- fn get_font_format_info(font_bytes: &[u8]) -> Box<FontFormatInfo>;
-- fn is_colrv1(format_info: &FontFormatInfo) -> bool;
-- fn is_colrv0(format_info: &FontFormatInfo) -> bool;
-- fn is_cbdt_cblc(format_info: &FontFormatInfo) -> bool;
-- fn is_ebdt_eblc(format_info: &FontFormatInfo) -> bool;
-- fn is_variable(format_info: &FontFormatInfo) -> bool;
-- fn is_sbix(format_info: &FontFormatInfo) -> bool;
-- fn is_cff2(format_info: &FontFormatInfo) -> bool;
-- fn is_avar2(format_info: &FontFormatInfo) -> bool;
-- }
--}
++
++#[cxx::bridge(namespace = "font_format_check")]
++pub mod ffi {
++ extern "Rust" {
++ type FontFormatInfo;
++
++ fn get_font_format_info(font_bytes: &[u8]) -> Box<FontFormatInfo>;
++ fn is_colrv1(format_info: &FontFormatInfo) -> bool;
++ fn is_colrv0(format_info: &FontFormatInfo) -> bool;
++ fn is_cbdt_cblc(format_info: &FontFormatInfo) -> bool;
++ fn is_ebdt_eblc(format_info: &FontFormatInfo) -> bool;
++ fn is_variable(format_info: &FontFormatInfo) -> bool;
++ fn is_sbix(format_info: &FontFormatInfo) -> bool;
++ fn is_cff2(format_info: &FontFormatInfo) -> bool;
++ fn is_avar2(format_info: &FontFormatInfo) -> bool;
++ }
++}
diff --git a/chromium-154-ftbfs-private-verification-tokens.patch b/chromium-154-ftbfs-private-verification-tokens.patch
new file mode 100644
index 0000000..90bfd61
--- /dev/null
+++ b/chromium-154-ftbfs-private-verification-tokens.patch
@@ -0,0 +1,297 @@
+ungoogled chromium patch from https://github.com/ungoogled-software/ungoogled-chromium/pull/3966
+
+--- a/chrome/browser/BUILD.gn
++++ b/chrome/browser/BUILD.gn
+@@ -1022,7 +1022,6 @@ source_set("core") {
+ "//chrome/browser/preloading/search_preload:feature",
+ "//chrome/browser/privacy_sandbox:headers",
+ "//chrome/browser/private_ai",
+- "//chrome/browser/private_verification_tokens",
+ "//chrome/browser/profiles:misc",
+ "//chrome/browser/profiles:profile_io_data",
+ "//chrome/browser/profiles:profiles_extra_parts",
+@@ -2215,7 +2214,6 @@ source_set("browser") {
+ "//chrome/browser/preloading/search_preload",
+ "//chrome/browser/privacy",
+ "//chrome/browser/privacy_sandbox:impl",
+- "//chrome/browser/private_verification_tokens",
+ "//chrome/browser/profiles:misc",
+ "//chrome/browser/profiles:profile_util_impl",
+ "//chrome/browser/profiles:profiles_extra_parts_impl",
+--- a/chrome/browser/browsing_data/BUILD.gn
++++ b/chrome/browser/browsing_data/BUILD.gn
+@@ -125,7 +125,6 @@ source_set("impl") {
+ "//chrome/browser/preloading/prefetch/no_state_prefetch",
+ "//chrome/browser/preloading/prefetch/search_prefetch",
+ "//chrome/browser/privacy_sandbox:headers",
+- "//chrome/browser/private_verification_tokens",
+ "//chrome/browser/profiles/keep_alive",
+ "//chrome/browser/reading_list",
+ "//chrome/browser/safe_browsing",
+@@ -267,7 +266,6 @@ source_set("unit_tests") {
+ "//chrome/browser/payments/browser_binding:browser_bound_key_deleter",
+ "//chrome/browser/payments/browser_binding:test_support",
+ "//chrome/browser/permissions",
+- "//chrome/browser/private_verification_tokens",
+ "//chrome/browser/reading_list",
+ "//chrome/browser/safe_browsing:verdict_cache_manager_factory",
+ "//chrome/browser/segmentation_platform",
+@@ -295,7 +293,6 @@ source_set("unit_tests") {
+ "//components/privacy_sandbox:privacy_sandbox_settings_headers",
+ "//components/privacy_sandbox/privacy_sandbox_attestations",
+ "//components/privacy_sandbox/privacy_sandbox_attestations:test_support",
+- "//components/private_verification_tokens/common:private_verification_tokens_database",
+ "//components/reading_list/core:test_support",
+ "//components/safe_browsing/core/browser:verdict_cache_manager",
+ "//components/site_engagement/content",
+--- a/chrome/browser/browsing_data/chrome_browsing_data_model_delegate.cc
++++ b/chrome/browser/browsing_data/chrome_browsing_data_model_delegate.cc
+@@ -127,15 +127,6 @@ void ChromeBrowsingDataModelDelegate::Ge
+
+ GetAllMediaDeviceSaltDataKeys(concurrent.CreateCallback(), {});
+
+- if (base::FeatureList::IsEnabled(
+- net::features::kEnablePrivateVerificationTokens)) {
+- if (auto* pvt_service =
+- PrivateVerificationTokensServiceFactory::GetForProfile(profile_)) {
+- pvt_service->GetTokenIssuers(
+- base::BindOnce(&PrivateVerificationTokenBrowsingDataToDelegateEntries)
+- .Then(concurrent.CreateCallback()));
+- }
+- }
+
+ // TODO(crbug.com/40205603): Implement data retrieval for remaining data
+ // types.
+@@ -180,20 +171,6 @@ void ChromeBrowsingDataModelDelegate::Re
+ }
+ #endif // !BUILDFLAG(IS_ANDROID)
+
+- if (base::FeatureList::IsEnabled(
+- net::features::kEnablePrivateVerificationTokens) &&
+- storage_types.Has(static_cast<BrowsingDataModel::StorageType>(
+- StorageType::kPrivateVerificationTokens))) {
+- if (const url::Origin* origin = std::get_if<url::Origin>(&data_key)) {
+- if (auto* pvt_service =
+- PrivateVerificationTokensServiceFactory::GetForProfile(
+- profile_)) {
+- pvt_service->DeleteTokens(base::Time(), base::Time::Max(),
+- concurrent.CreateClosure(),
+- std::vector<url::Origin>{*origin});
+- }
+- }
+- }
+
+ std::move(concurrent).Done(std::move(callback));
+ }
+--- a/chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.cc
++++ b/chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.cc
+@@ -720,29 +720,6 @@ void ChromeBrowsingDataRemoverDelegate::
+ #endif // BUILDFLAG(IS_CHROMEOS)
+ }
+
+- //////////////////////////////////////////////////////////////////////////////
+- // DATA_TYPE_PRIVATE_VERIFICATION_TOKENS
+- if (remove_mask & constants::DATA_TYPE_PRIVATE_VERIFICATION_TOKENS) {
+- if (base::FeatureList::IsEnabled(
+- net::features::kEnablePrivateVerificationTokens)) {
+- if (auto* pvt_service =
+- PrivateVerificationTokensServiceFactory::GetForProfile(
+- profile_)) {
+- auto done_closure = CreateTaskCompletionClosure(
+- TracingDataType::kPrivateVerificationTokens);
+-
+- if (filter_builder->MatchesAllOriginsAndDomains()) {
+- pvt_service->DeleteTokens(delete_begin_, delete_end_,
+- std::move(done_closure),
+- /*issuers=*/std::nullopt);
+- } else {
+- pvt_service->DeleteTokensByFilter(
+- delete_begin_, delete_end_,
+- filter_builder->BuildStorageKeyFilter(), std::move(done_closure));
+- }
+- }
+- }
+- }
+
+ //////////////////////////////////////////////////////////////////////////////
+ // DATA_TYPE_CONTENT_SETTINGS
+--- a/chrome/browser/chrome_content_browser_client.cc
++++ b/chrome/browser/chrome_content_browser_client.cc
+@@ -6009,21 +6009,6 @@ ChromeContentBrowserClient::CreateURLLoa
+ result.push_back(std::move(signin_throttle));
+ }
+
+- if (base::FeatureList::IsEnabled(
+- net::features::kEnablePrivateVerificationTokens) &&
+- request.is_outermost_main_frame) {
+- if (auto* pvt_service =
+- PrivateVerificationTokensServiceFactory::GetForProfile(profile)) {
+- auto url_loader_factory = profile->GetDefaultStoragePartition()
+- ->GetURLLoaderFactoryForBrowserProcess();
+- if (auto pvt_throttle =
+- PrivateVerificationTokensURLLoaderThrottle::Create(
+- pvt_service, profile->IsOffTheRecord(),
+- std::move(url_loader_factory))) {
+- result.push_back(std::move(pvt_throttle));
+- }
+- }
+- }
+
+ if (auto contextual_tasks_throttle =
+ contextual_tasks::ContextualTasksURLLoaderThrottle::MaybeCreate(
+--- a/chrome/browser/component_updater/BUILD.gn
++++ b/chrome/browser/component_updater/BUILD.gn
+@@ -147,7 +147,6 @@ source_set("impl") {
+ "//chrome/browser/net",
+ "//chrome/browser/page_load_metrics",
+ "//chrome/browser/permissions",
+- "//chrome/browser/private_verification_tokens",
+ "//chrome/browser/profiles:profile",
+ "//chrome/browser/update_client",
+ "//chrome/common",
+@@ -163,7 +162,6 @@ source_set("impl") {
+ "//components/permissions",
+ "//components/privacy_sandbox:features",
+ "//components/privacy_sandbox/privacy_sandbox_attestations",
+- "//components/private_verification_tokens/common:private_verification_tokens_issuer_config",
+ "//components/safe_browsing/core/common:features",
+ "//components/search",
+ "//components/security_interstitials/content:security_interstitial_page",
+--- a/chrome/browser/component_updater/private_verification_tokens_installer.cc
++++ b/chrome/browser/component_updater/private_verification_tokens_installer.cc
+@@ -25,32 +25,6 @@ namespace component_updater {
+
+ void RegisterPrivateVerificationTokensComponentIfEnabled(
+ ComponentUpdateService* cus) {
+- if (!base::FeatureList::IsEnabled(
+- net::features::kEnablePrivateVerificationTokens)) {
+- return;
+- }
+-
+- auto installer = base::MakeRefCounted<ComponentInstaller>(
+- std::make_unique<PrivateVerificationTokensInstallerPolicy>(
+- base::BindRepeating(
+- [](scoped_refptr<private_verification_tokens::
+- PrivateVerificationTokensIssuerConfig>
+- issuer_config) {
+- PrivateVerificationTokensServiceFactory::SetGlobalIssuerConfig(
+- issuer_config);
+- if (g_browser_process && g_browser_process->profile_manager()) {
+- for (Profile* profile : g_browser_process->profile_manager()
+- ->GetLoadedProfiles()) {
+- if (PrivateVerificationTokensService* service =
+- PrivateVerificationTokensServiceFactory::
+- GetForProfileIfExists(profile)) {
+- service->SetIssuerConfig(issuer_config);
+- }
+- }
+- }
+- })));
+-
+- installer->Register(cus, base::OnceClosure());
+ }
+
+ } // namespace component_updater
+--- a/chrome/browser/private_verification_tokens/BUILD.gn
++++ b/chrome/browser/private_verification_tokens/BUILD.gn
+@@ -26,11 +26,6 @@ static_library("private_verification_tok
+ "//chrome/browser/profiles:profile",
+ "//components/content_settings/core/browser",
+ "//components/keyed_service/core",
+- "//components/private_verification_tokens/common:privacy_pass_athm_batch_request",
+- "//components/private_verification_tokens/common:private_verification_tokens_fetcher",
+- "//components/private_verification_tokens/common:private_verification_tokens_issuer_config",
+- "//components/private_verification_tokens/common:private_verification_tokens_parameters",
+- "//components/private_verification_tokens/common:private_verification_tokens_store",
+ "//content/public/browser",
+ "//net",
+ "//services/network/public/cpp",
+@@ -49,9 +44,6 @@ source_set("browser_tests") {
+ "//chrome/browser/content_settings:content_settings_factory",
+ "//chrome/test:test_support",
+ "//components/content_settings/core/common",
+- "//components/private_verification_tokens/common:athm_test_issuer",
+- "//components/private_verification_tokens/common:private_verification_tokens_database",
+- "//components/private_verification_tokens/common:private_verification_tokens_issuer_config",
+ "//net:test_support",
+ "//services/network:test_support",
+ "//url",
+@@ -72,11 +64,6 @@ source_set("unit_tests") {
+ "//chrome/test:test_support",
+ "//components/content_settings/core/browser",
+ "//components/content_settings/core/common",
+- "//components/private_verification_tokens/common:athm_test_issuer",
+- "//components/private_verification_tokens/common:private_verification_tokens_database",
+- "//components/private_verification_tokens/common:private_verification_tokens_issuer_config",
+- "//components/private_verification_tokens/common:private_verification_tokens_parameters",
+- "//components/private_verification_tokens/common:test_support",
+ "//content/test:test_support",
+ "//net",
+ "//services/network:test_support",
+--- a/chrome/browser/profiles/BUILD.gn
++++ b/chrome/browser/profiles/BUILD.gn
+@@ -809,7 +809,6 @@ source_set("profiles_extra_parts_impl")
+ "//chrome/browser/privacy_sandbox:headers",
+ "//chrome/browser/private_ai",
+ "//chrome/browser/private_insights",
+- "//chrome/browser/private_verification_tokens",
+ "//chrome/browser/push_messaging",
+ "//chrome/browser/reading_list",
+ "//chrome/browser/reduce_accept_language",
+--- a/chrome/browser/profiles/chrome_browser_main_extra_parts_profiles.cc
++++ b/chrome/browser/profiles/chrome_browser_main_extra_parts_profiles.cc
+@@ -1371,7 +1371,6 @@ void ChromeBrowserMainExtraPartsProfiles
+ PrivacyMetricsServiceFactory::GetInstance();
+ PrivacySandboxServiceFactory::GetInstance();
+ PrivacySandboxSettingsFactory::GetInstance();
+- PrivateVerificationTokensServiceFactory::GetInstance();
+ private_ai::PrivateAiServiceFactory::GetInstance();
+ ProfileNetworkContextServiceFactory::GetInstance();
+ ProfilePasswordStoreFactory::GetInstance();
+--- a/chrome/test/BUILD.gn
++++ b/chrome/test/BUILD.gn
+@@ -2137,7 +2137,6 @@ if (!is_android) {
+ "//chrome/browser/privacy_sandbox:headers",
+ "//chrome/browser/privacy_sandbox:test_support",
+ "//chrome/browser/private_ai",
+- "//chrome/browser/private_verification_tokens:browser_tests",
+ "//chrome/browser/profile_resetter",
+ "//chrome/browser/profile_resetter:browser_tests",
+ "//chrome/browser/profiles",
+@@ -5401,7 +5400,6 @@ test("unit_tests") {
+ "//chrome/browser/preloading/prerender:unit_tests",
+ "//chrome/browser/privacy_sandbox:unit_tests",
+ "//chrome/browser/private_ai:unit_tests",
+- "//chrome/browser/private_verification_tokens:unit_tests",
+ "//chrome/browser/profiles",
+ "//chrome/browser/profiles:misc",
+ "//chrome/browser/profiles:profile_downloader",
+--- a/components/BUILD.gn
++++ b/components/BUILD.gn
+@@ -314,7 +314,6 @@ test("components_unittests") {
+ "//components/power_metrics:unit_tests",
+ "//components/prefs:unit_tests",
+ "//components/privacy_sandbox:unit_tests",
+- "//components/private_verification_tokens:unit_tests",
+ "//components/profile_metrics:unit_tests",
+ "//components/proto_extras:unit_tests",
+ "//components/proxy_config:unit_tests",
+--- a/components/component_updater/installer_policies/BUILD.gn
++++ b/components/component_updater/installer_policies/BUILD.gn
+@@ -38,7 +38,6 @@ static_library("installer_policies_no_co
+ "//components/lookalikes/core:proto",
+ "//components/lookalikes/core:safety_tips",
+ "//components/prefs",
+- "//components/private_verification_tokens/common:private_verification_tokens_issuer_config",
+ "//components/update_client",
+ "//mojo/public/cpp/base:protobuf_support",
+ "//services/network/public/cpp",
+@@ -106,8 +105,6 @@ source_set("unit_tests") {
+ "//components/history_embeddings/core",
+ "//components/optimization_guide/core",
+ "//components/optimization_guide/proto:optimization_guide_proto",
+- "//components/private_verification_tokens/common:private_verification_tokens_issuer_config",
+- "//components/private_verification_tokens/common:test_support",
+ "//mojo/public/cpp/base:protobuf_support",
+ "//services/network/public/cpp",
+ "//testing/gmock",
diff --git a/chromium.spec b/chromium.spec
index 47ed9c8..6e71491 100644
--- a/chromium.spec
+++ b/chromium.spec
@@ -327,8 +327,7 @@ Patch93: chromium-141-csss_style_sheet.patch
# revert the patch to fix the build error: "ld.lld: error: undefined symbol: __sanitizer_set_death_callback"
Patch94: chromium-148-v8-sanitize-build-error.patch
-# Fix rust build error
-Patch95: chromium-152-build-error-rust-cbor.patch
+
# FTBFS - error: cannot find attribute `sanitize` in this scope
# --> ../../third_party/crabbyavif/src/src/capi/io.rs:210:41
# |
@@ -403,8 +402,14 @@ Patch311: chromium-123-fstack-protector-strong.patch
# ERROR at //build/rust/crubit/BUILD.gn:12:5:
# Unable to load third_party/rust-toolchain/lib/third_party/crubit/support/rs_std/BUILD.gn
# "$crubit_src_dir/support/rs_std:rs_std_cpp",
+# Patch from https://github.com/ungoogled-software/ungoogled-chromium/pull/3966
Patch312: chromium-154-ftbfs-crubit.patch
+# Fix FTBFS:
+# ERROR Unresolved dependencies
+# Patch from https://github.com/ungoogled-software/ungoogled-chromium/pull/3966
+Patch313: chromium-154-ftbfs-private-verification-tokens.patch
+
# old rust version causes build error on el8:
# error[E0599]: no method named `is_none_or` found for enum `Option` in the current scope
Patch314: chromium-136-rust-skrifa-build-error.patch
@@ -1108,7 +1113,6 @@ Qt6 UI for chromium.
%patch -P92 -p1 -b .nodejs-checkversion
%patch -P93 -p1 -b .ftbfs-csss_style_sheet
%patch -P94 -p1 -R -b .v8-sanitize-build-error
-%patch -P95 -p1 -b .build-error-rust-cbor
%patch -P96 -p1 -b .crabbyavif-ftbfs-old-rust
%if ! %{bundleffmpegfree}
@@ -1162,7 +1166,8 @@ Qt6 UI for chromium.
%patch -P315 -p1 -b .rustc-ftbfs
%patch -P310 -p1 -b .rust-FTBFS-suppress-warnings
%patch -P311 -p1 -b .fstack-protector-strong
-%patch -P312 -p1 -R -b .ftbfs-crubit
+%patch -P312 -p1 -b .ftbfs-crubit
+%patch -P313 -p1 -b .ftbfs-private-verification-tokens
%if 0%{?rhel} && 0%{?rhel} < 10
%patch -P354 -p1 -b .split-threshold-for-reg-with-hint
@@ -1403,7 +1408,6 @@ CHROMIUM_CORE_GN_DEFINES+=' host_toolchain="//build/toolchain/linux/unbundle:def
CHROMIUM_BROWSER_GN_DEFINES+=' use_custom_libcxx=false'
%endif
CHROMIUM_CORE_GN_DEFINES+=' is_debug=false dcheck_always_on=false dcheck_is_configurable=false'
-CHROMIUM_CORE_GN_DEFINES+=' enable_enterprise_companion=false'
CHROMIUM_CORE_GN_DEFINES+=' system_libdir="%{_lib}"'
%if %{official_build}
^ permalink raw reply related [flat|nested] only message in thread
only message in thread, other threads:[~2026-09-23 18:21 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-09-23 18:21 [rpms/chromium] f44: Fix FTBFS (patch from ungoogled chromium) Than Ngo
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox