diff options
Diffstat (limited to 'www-client/chromium/files')
4 files changed, 562 insertions, 0 deletions
diff --git a/www-client/chromium/files/chromium-103-FrameLoadRequest-type.patch b/www-client/chromium/files/chromium-103-FrameLoadRequest-type.patch new file mode 100644 index 0000000..cdace4b --- /dev/null +++ b/www-client/chromium/files/chromium-103-FrameLoadRequest-type.patch @@ -0,0 +1,26 @@ +From 491bf840da4f76fa3591cc0aa2f4c19cdbe57ec4 Mon Sep 17 00:00:00 2001 +From: Stephan Hartmann <stha09@googlemail.com> +Date: Thu, 12 May 2022 11:58:29 +0000 +Subject: [PATCH] GCC: fix ambiguous references in blink::FrameLoadRequest + +Add namespace to avoid confusion. +--- + third_party/blink/renderer/core/loader/frame_load_request.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/third_party/blink/renderer/core/loader/frame_load_request.h b/third_party/blink/renderer/core/loader/frame_load_request.h +index 444b25c..a86814d 100644 +--- a/third_party/blink/renderer/core/loader/frame_load_request.h ++++ b/third_party/blink/renderer/core/loader/frame_load_request.h +@@ -179,7 +179,7 @@ struct CORE_EXPORT FrameLoadRequest { + impression_ = impression; + } + +- const absl::optional<Impression>& Impression() const { return impression_; } ++ const absl::optional<blink::Impression>& Impression() const { return impression_; } + + bool CanDisplay(const KURL&) const; + +-- +2.35.1 + diff --git a/www-client/chromium/files/chromium-103-SubstringSetMatcher-packed.patch b/www-client/chromium/files/chromium-103-SubstringSetMatcher-packed.patch new file mode 100644 index 0000000..03e9bd8 --- /dev/null +++ b/www-client/chromium/files/chromium-103-SubstringSetMatcher-packed.patch @@ -0,0 +1,70 @@ +From 3d274856e792a361336eb4ae1670bc9c1905f0cb Mon Sep 17 00:00:00 2001 +From: Steinar H. Gunderson <sesse@chromium.org> +Date: Thu, 12 May 2022 16:42:40 +0200 +Subject: [PATCH] Make AhoCorasickNode 4-aligned. + +This should fix an issue where std::vector could allocate unaligned +memory for AhoCorasickNode, and we'd then return a pointer to +inline_edges, where a caller would expect the pointer to be aligned +but it wasn't. + +Change-Id: Id9dff044c61f8e46062c63b8480b18ebc68c4862 +--- + +diff --git a/components/url_matcher/substring_set_matcher.cc b/components/url_matcher/substring_set_matcher.cc +index e110047..ef0b750 100644 +--- a/components/url_matcher/substring_set_matcher.cc ++++ b/components/url_matcher/substring_set_matcher.cc +@@ -424,7 +424,12 @@ + edges_.inline_edges[num_edges()] = AhoCorasickEdge{label, node}; + if (label == kFailureNodeLabel) { + // Make sure that kFailureNodeLabel is first. +- std::swap(edges_.inline_edges[0], edges_.inline_edges[num_edges()]); ++ // NOTE: We don't use std::swap here, because GCC ++ // doesn't understand that inline_edges[] is 4-aligned ++ // and gives a warning. ++ AhoCorasickEdge temp = edges_.inline_edges[0]; ++ edges_.inline_edges[0] = edges_.inline_edges[num_edges()]; ++ edges_.inline_edges[num_edges()] = temp; + } + --num_free_edges_; + return; +diff --git a/components/url_matcher/substring_set_matcher.cc b/components/url_matcher/substring_set_matcher.cc +index e110047..ef0b750 100644 +--- a/components/url_matcher/substring_set_matcher.h ++++ b/components/url_matcher/substring_set_matcher.h +@@ -154,8 +154,9 @@ + static constexpr uint32_t kEmptyLabel = 0x103; + + // A node in the trie, packed tightly together so that it occupies 12 bytes +- // (both on 32- and 64-bit platforms). +- class AhoCorasickNode { ++ // (both on 32- and 64-bit platforms), but aligned to at least 4 (see the ++ // comment on edges_). ++ class alignas(AhoCorasickEdge) AhoCorasickNode { + public: + AhoCorasickNode(); + ~AhoCorasickNode(); +@@ -178,6 +179,10 @@ + NodeID GetEdgeNoInline(uint32_t label) const; + void SetEdge(uint32_t label, NodeID node); + const AhoCorasickEdge* edges() const { ++ // NOTE: Returning edges_.inline_edges here is fine, because it's ++ // the first thing in the struct (see the comment on edges_). ++ DCHECK_EQ(0u, reinterpret_cast<uintptr_t>(edges_.inline_edges) % ++ alignof(AhoCorasickEdge)); + return edges_capacity_ == 0 ? edges_.inline_edges : edges_.edges; + } + +@@ -258,6 +263,11 @@ + // in the first slot if it exists (ie., is not equal to kRootID), since we + // need to access that label during every single node we look at during + // traversal. ++ // ++ // NOTE: Keep this the first member in the struct, so that inline_edges gets ++ // 4-aligned (since the class is marked as such, despite being packed. ++ // Otherwise, edges() can return an unaligned pointer marked as aligned ++ // (the unalignedness gets lost). + static constexpr int kNumInlineEdges = 2; + union { + // Out-of-line edge storage, having room for edges_capacity_ elements. diff --git a/www-client/chromium/files/chromium-103-VirtualCursor-std-layout.patch b/www-client/chromium/files/chromium-103-VirtualCursor-std-layout.patch new file mode 100644 index 0000000..be0502e --- /dev/null +++ b/www-client/chromium/files/chromium-103-VirtualCursor-std-layout.patch @@ -0,0 +1,231 @@ +From 144479ad7b4287bee4067f95e4218f614798a865 Mon Sep 17 00:00:00 2001 +From: Stephan Hartmann <stha09@googlemail.com> +Date: Sun, 16 Jan 2022 19:15:26 +0000 +Subject: [PATCH] sql: make VirtualCursor standard layout type + +sql::recover::VirtualCursor needs to be a standard layout type, but +has members of type std::unique_ptr. However, std::unique_ptr is not +guaranteed to be standard layout. Compiling with clang combined with +gcc-11 libstdc++ fails because of this. + +Bug: 1189788 +Change-Id: Ia6dc388cc5ef1c0f2afc75f8ca45b9f12687ca9c +--- + +diff --git a/sql/recover_module/btree.cc b/sql/recover_module/btree.cc +index cc9420e5..f12d8fa 100644 +--- a/sql/recover_module/btree.cc ++++ b/sql/recover_module/btree.cc +@@ -136,16 +136,22 @@ + "Move the destructor to the .cc file if it's non-trival"); + #endif // !DCHECK_IS_ON() + +-LeafPageDecoder::LeafPageDecoder(DatabasePageReader* db_reader) noexcept +- : page_id_(db_reader->page_id()), +- db_reader_(db_reader), +- cell_count_(ComputeCellCount(db_reader)), +- next_read_index_(0), +- last_record_size_(0) { ++LeafPageDecoder::LeafPageDecoder() noexcept = default; ++ ++void LeafPageDecoder::Initialize(DatabasePageReader* db_reader) { ++ page_id_ = db_reader->page_id(); ++ db_reader_ = db_reader; ++ cell_count_ = ComputeCellCount(db_reader); ++ next_read_index_ = 0; ++ last_record_size_ = 0; + DCHECK(IsOnValidPage(db_reader)); + DCHECK(DatabasePageReader::IsValidPageId(page_id_)); + } + ++void LeafPageDecoder::Reset() { ++ db_reader_ = nullptr; ++} ++ + bool LeafPageDecoder::TryAdvance() { + DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); + DCHECK(CanAdvance()); +diff --git a/sql/recover_module/btree.h b/sql/recover_module/btree.h +index eaa087a5..df0e0c9 100644 +--- a/sql/recover_module/btree.h ++++ b/sql/recover_module/btree.h +@@ -101,9 +101,7 @@ + public: + // Creates a decoder for a DatabasePageReader's last read page. + // +- // |db_reader| must have been used to read an inner page of a table B-tree. +- // |db_reader| must outlive this instance. +- explicit LeafPageDecoder(DatabasePageReader* db_reader) noexcept; ++ LeafPageDecoder() noexcept; + ~LeafPageDecoder() noexcept = default; + + LeafPageDecoder(const LeafPageDecoder&) = delete; +@@ -151,6 +149,17 @@ + // read as long as CanAdvance() returns true. + bool TryAdvance(); + ++ // Initialize with DatabasePageReader ++ // |db_reader| must have been used to read an inner page of a table B-tree. ++ // |db_reader| must outlive this instance. ++ void Initialize(DatabasePageReader* db_reader); ++ ++ // Reset internal DatabasePageReader ++ void Reset(); ++ ++ // True if DatabasePageReader is valid ++ bool IsValid() { return (db_reader_ != nullptr); } ++ + // True if the given reader may point to an inner page in a table B-tree. + // + // The last ReadPage() call on |db_reader| must have succeeded. +@@ -164,14 +173,14 @@ + static int ComputeCellCount(DatabasePageReader* db_reader); + + // The number of the B-tree page this reader is reading. +- const int64_t page_id_; ++ int64_t page_id_; + // Used to read the tree page. + // + // Raw pointer usage is acceptable because this instance's owner is expected + // to ensure that the DatabasePageReader outlives this. +- DatabasePageReader* const db_reader_; ++ DatabasePageReader* db_reader_; + // Caches the ComputeCellCount() value for this reader's page. +- const int cell_count_ = ComputeCellCount(db_reader_); ++ int cell_count_; + + // The reader's cursor state. + // +diff --git a/sql/recover_module/cursor.cc b/sql/recover_module/cursor.cc +index 4f827ed..240de499 100644 +--- a/sql/recover_module/cursor.cc ++++ b/sql/recover_module/cursor.cc +@@ -28,7 +28,7 @@ + int VirtualCursor::First() { + DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); + inner_decoders_.clear(); +- leaf_decoder_ = nullptr; ++ leaf_decoder_.Reset(); + + AppendPageDecoder(table_->root_page_id()); + return Next(); +@@ -38,18 +38,18 @@ + DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); + record_reader_.Reset(); + +- while (!inner_decoders_.empty() || leaf_decoder_.get()) { +- if (leaf_decoder_.get()) { +- if (!leaf_decoder_->CanAdvance()) { ++ while (!inner_decoders_.empty() || leaf_decoder_.IsValid()) { ++ if (leaf_decoder_.IsValid()) { ++ if (!leaf_decoder_.CanAdvance()) { + // The leaf has been exhausted. Remove it from the DFS stack. +- leaf_decoder_ = nullptr; ++ leaf_decoder_.Reset(); + continue; + } +- if (!leaf_decoder_->TryAdvance()) ++ if (!leaf_decoder_.TryAdvance()) + continue; + +- if (!payload_reader_.Initialize(leaf_decoder_->last_record_size(), +- leaf_decoder_->last_record_offset())) { ++ if (!payload_reader_.Initialize(leaf_decoder_.last_record_size(), ++ leaf_decoder_.last_record_offset())) { + continue; + } + if (!record_reader_.Initialize()) +@@ -101,13 +101,13 @@ + int64_t VirtualCursor::RowId() { + DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); + DCHECK(record_reader_.IsInitialized()); +- DCHECK(leaf_decoder_.get()); +- return leaf_decoder_->last_record_rowid(); ++ DCHECK(leaf_decoder_.IsValid()); ++ return leaf_decoder_.last_record_rowid(); + } + + void VirtualCursor::AppendPageDecoder(int page_id) { + DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); +- DCHECK(leaf_decoder_.get() == nullptr) ++ DCHECK(!leaf_decoder_.IsValid()) + << __func__ + << " must only be called when the current path has no leaf decoder"; + +@@ -115,7 +115,7 @@ + return; + + if (LeafPageDecoder::IsOnValidPage(&db_reader_)) { +- leaf_decoder_ = std::make_unique<LeafPageDecoder>(&db_reader_); ++ leaf_decoder_.Initialize(&db_reader_); + return; + } + +diff --git a/sql/recover_module/cursor.h b/sql/recover_module/cursor.h +index 845b785..cc4e85f8 100644 +--- a/sql/recover_module/cursor.h ++++ b/sql/recover_module/cursor.h +@@ -130,7 +130,7 @@ + std::vector<std::unique_ptr<InnerPageDecoder>> inner_decoders_; + + // Decodes the leaf page containing records. +- std::unique_ptr<LeafPageDecoder> leaf_decoder_; ++ LeafPageDecoder leaf_decoder_; + + SEQUENCE_CHECKER(sequence_checker_); + }; +diff --git a/sql/recover_module/pager.cc b/sql/recover_module/pager.cc +index 58e75de..69d98cef 100644 +--- a/sql/recover_module/pager.cc ++++ b/sql/recover_module/pager.cc +@@ -23,8 +23,7 @@ + "ints are not appropriate for representing page IDs"); + + DatabasePageReader::DatabasePageReader(VirtualTable* table) +- : page_data_(std::make_unique<uint8_t[]>(table->page_size())), +- table_(table) { ++ : page_data_(table->page_size()), table_(table) { + DCHECK(table != nullptr); + DCHECK(IsValidPageSize(table->page_size())); + } +@@ -58,7 +57,7 @@ + "The |read_offset| computation above may overflow"); + + int sqlite_status = +- RawRead(sqlite_file, read_size, read_offset, page_data_.get()); ++ RawRead(sqlite_file, read_size, read_offset, page_data_.data()); + + // |page_id_| needs to be set to kInvalidPageId if the read failed. + // Otherwise, future ReadPage() calls with the previous |page_id_| value +diff --git a/sql/recover_module/pager.h b/sql/recover_module/pager.h +index 07cac3cb..d08f093 100644 +--- a/sql/recover_module/pager.h ++++ b/sql/recover_module/pager.h +@@ -6,8 +6,8 @@ + #define SQL_RECOVER_MODULE_PAGER_H_ + + #include <cstdint> +-#include <memory> + #include <ostream> ++#include <vector> + + #include "base/check_op.h" + #include "base/memory/raw_ptr.h" +@@ -72,7 +72,7 @@ + DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); + DCHECK_NE(page_id_, kInvalidPageId) + << "Successful ReadPage() required before accessing pager state"; +- return page_data_.get(); ++ return page_data_.data(); + } + + // The number of bytes in the page read by the last ReadPage() call. +@@ -139,7 +139,7 @@ + int page_id_ = kInvalidPageId; + // Stores the bytes of the last page successfully read by ReadPage(). + // The content is undefined if the last call to ReadPage() did not succeed. +- const std::unique_ptr<uint8_t[]> page_data_; ++ std::vector<uint8_t> page_data_; + // Raw pointer usage is acceptable because this instance's owner is expected + // to ensure that the VirtualTable outlives this. + const raw_ptr<VirtualTable> table_; diff --git a/www-client/chromium/files/chromium-103-compiler.patch b/www-client/chromium/files/chromium-103-compiler.patch new file mode 100644 index 0000000..e1469bf --- /dev/null +++ b/www-client/chromium/files/chromium-103-compiler.patch @@ -0,0 +1,235 @@ +From 307a0f63dd9b118f4b8470ed3d7567e81fdb7a6d Mon Sep 17 00:00:00 2001 +From: Mike Gilbert <floppym@gentoo.org> +Date: Tue, 3 May 2022 10:51:55 +0000 +Subject: [PATCH] Disable various compiler configs + +--- + build/config/compiler/BUILD.gn | 114 +++++---------------------------- + 1 file changed, 17 insertions(+), 97 deletions(-) + +diff --git a/build/config/compiler/BUILD.gn b/build/config/compiler/BUILD.gn +index f378b95..cb2aeb3 100644 +--- a/build/config/compiler/BUILD.gn ++++ b/build/config/compiler/BUILD.gn +@@ -286,9 +286,7 @@ config("compiler") { + + configs += [ + # See the definitions below. +- ":clang_revision", + ":rustc_revision", +- ":compiler_cpu_abi", + ":compiler_codegen", + ":compiler_deterministic", + ] +@@ -522,31 +520,6 @@ config("compiler") { + ldflags += [ "-Wl,-z,keep-text-section-prefix" ] + } + +- if (is_clang && !is_nacl && current_os != "zos") { +- cflags += [ "-fcrash-diagnostics-dir=" + clang_diagnostic_dir ] +- +- # TODO(hans): Remove this once Clang generates better optimized debug info +- # by default. https://crbug.com/765793 +- cflags += [ +- "-mllvm", +- "-instcombine-lower-dbg-declare=0", +- ] +- if (!is_debug && use_thin_lto && is_a_target_toolchain) { +- if (is_win) { +- ldflags += [ "-mllvm:-instcombine-lower-dbg-declare=0" ] +- } else { +- ldflags += [ "-Wl,-mllvm,-instcombine-lower-dbg-declare=0" ] +- } +- } +- +- # TODO(crbug.com/1235145): Investigate why/if this should be needed. +- if (is_win) { +- cflags += [ "/clang:-ffp-contract=off" ] +- } else { +- cflags += [ "-ffp-contract=off" ] +- } +- } +- + # Rust compiler setup (for either clang or rustc). + if (enable_rust) { + defines += [ "RUST_ENABLED" ] +@@ -1231,45 +1204,6 @@ config("compiler_deterministic") { + } + } + +- # Makes builds independent of absolute file path. +- if (is_clang && strip_absolute_paths_from_debug_symbols) { +- # If debug option is given, clang includes $cwd in debug info by default. +- # For such build, this flag generates reproducible obj files even we use +- # different build directory like "out/feature_a" and "out/feature_b" if +- # we build same files with same compile flag. +- # Other paths are already given in relative, no need to normalize them. +- if (is_nacl) { +- # TODO(https://crbug.com/1231236): Use -ffile-compilation-dir= here. +- cflags += [ +- "-Xclang", +- "-fdebug-compilation-dir", +- "-Xclang", +- ".", +- ] +- } else { +- # -ffile-compilation-dir is an alias for both -fdebug-compilation-dir= +- # and -fcoverage-compilation-dir=. +- cflags += [ "-ffile-compilation-dir=." ] +- } +- if (!is_win) { +- # We don't use clang -cc1as on Windows (yet? https://crbug.com/762167) +- asmflags = [ "-Wa,-fdebug-compilation-dir,." ] +- } +- +- if (is_win && use_lld) { +- if (symbol_level == 2 || (is_clang && using_sanitizer)) { +- # Absolutize source file paths for PDB. Pass the real build directory +- # if the pdb contains source-level debug information and if linker +- # reproducibility is not critical. +- ldflags += [ "/PDBSourcePath:" + rebase_path(root_build_dir) ] +- } else { +- # Use a fake fixed base directory for paths in the pdb to make the pdb +- # output fully deterministic and independent of the build directory. +- ldflags += [ "/PDBSourcePath:o:\fake\prefix" ] +- } +- } +- } +- + # Tells the compiler not to use absolute paths when passing the default + # paths to the tools it invokes. We don't want this because we don't + # really need it and it can mess up the goma cache entries. +@@ -1534,15 +1468,6 @@ config("default_warnings") { + cflags += [ "-Wno-unqualified-std-cast-call" ] + } + +- if (!is_nacl && !(is_chromeos || +- default_toolchain == "//build/toolchain/cros:target")) { +- # TODO(https://crbug.com/1316298): Re-enable once test failure is figured out +- cflags += [ +- "-Xclang", +- "-no-opaque-pointers", +- ] +- } +- + if (is_fuchsia) { + # TODO(https://bugs.chromium.org/p/fuchsia/issues/detail?id=77383) + cflags += [ "-Wno-deprecated-copy" ] +@@ -1611,7 +1536,7 @@ config("chromium_code") { + defines = [ "_HAS_NODISCARD" ] + } + } else { +- cflags = [ "-Wall" ] ++ cflags = [] + if (treat_warnings_as_errors) { + cflags += [ "-Werror" ] + +@@ -1620,10 +1545,6 @@ config("chromium_code") { + # well. + ldflags = [ "-Werror" ] + } +- if (is_clang) { +- # Enable extra warnings for chromium_code when we control the compiler. +- cflags += [ "-Wextra" ] +- } + + # In Chromium code, we define __STDC_foo_MACROS in order to get the + # C99 macros on Mac and Linux. +@@ -1632,15 +1553,6 @@ config("chromium_code") { + "__STDC_FORMAT_MACROS", + ] + +- if (!is_debug && !using_sanitizer && current_cpu != "s390x" && +- current_cpu != "s390" && current_cpu != "ppc64" && +- current_cpu != "mips" && current_cpu != "mips64") { +- # Non-chromium code is not guaranteed to compile cleanly with +- # _FORTIFY_SOURCE. Also, fortified build may fail when optimizations are +- # disabled, so only do that for Release build. +- defines += [ "_FORTIFY_SOURCE=2" ] +- } +- + if (is_mac) { + cflags_objc = [ "-Wobjc-missing-property-synthesis" ] + cflags_objcc = [ "-Wobjc-missing-property-synthesis" ] +@@ -2031,7 +1943,8 @@ config("default_stack_frames") { + } + + # Default "optimization on" config. +-config("optimize") { ++config("optimize") { } ++config("xoptimize") { + if (is_win) { + if (chrome_pgo_phase != 2) { + # Favor size over speed, /O1 must be before the common flags. +@@ -2069,7 +1982,8 @@ config("optimize") { + } + + # Turn off optimizations. +-config("no_optimize") { ++config("no_optimize") { } ++config("xno_optimize") { + if (is_win) { + cflags = [ + "/Od", # Disable optimization. +@@ -2109,7 +2023,8 @@ config("no_optimize") { + # Turns up the optimization level. On Windows, this implies whole program + # optimization and link-time code generation which is very expensive and should + # be used sparingly. +-config("optimize_max") { ++config("optimize_max") { } ++config("xoptimize_max") { + if (is_nacl && is_nacl_irt) { + # The NaCl IRT is a special case and always wants its own config. + # Various components do: +@@ -2142,7 +2057,8 @@ config("optimize_max") { + # + # TODO(crbug.com/621335) - rework how all of these configs are related + # so that we don't need this disclaimer. +-config("optimize_speed") { ++config("optimize_speed") { } ++config("xoptimize_speed") { + if (is_nacl && is_nacl_irt) { + # The NaCl IRT is a special case and always wants its own config. + # Various components do: +@@ -2168,7 +2084,8 @@ config("optimize_speed") { + } + } + +-config("optimize_fuzzing") { ++config("optimize_fuzzing") { } ++config("xoptimize_fuzzing") { + cflags = [ "-O1" ] + common_optimize_on_cflags + rustflags = [ "-Copt-level=1" ] + ldflags = common_optimize_on_ldflags +@@ -2287,7 +2204,8 @@ config("win_pdbaltpath") { + } + + # Full symbols. +-config("symbols") { ++config("symbols") { } ++config("xsymbols") { + if (is_win) { + if (is_clang) { + cflags = [ "/Z7" ] # Debug information in the .obj files. +@@ -2415,7 +2333,8 @@ config("symbols") { + # Minimal symbols. + # This config guarantees to hold symbol for stack trace which are shown to user + # when crash happens in unittests running on buildbot. +-config("minimal_symbols") { ++config("minimal_symbols") { } ++config("xminimal_symbols") { + if (is_win) { + # Functions, files, and line tables only. + cflags = [] +@@ -2488,7 +2407,8 @@ config("minimal_symbols") { + # This configuration contains function names only. That is, the compiler is + # told to not generate debug information and the linker then just puts function + # names in the final debug information. +-config("no_symbols") { ++config("no_symbols") { } ++config("xno_symbols") { + if (is_win) { + ldflags = [ "/DEBUG" ] + +-- +2.35.1 |