diff --git a/extra/chromium/0001-widevine-support-for-arm.patch b/extra/chromium/0001-widevine-support-for-arm.patch index 698169753..2e9cda64a 100644 --- a/extra/chromium/0001-widevine-support-for-arm.patch +++ b/extra/chromium/0001-widevine-support-for-arm.patch @@ -1,4 +1,4 @@ -From e66c6a6b9796a96827f16894b4d03667910bf175 Mon Sep 17 00:00:00 2001 +From bdd6fbee97e8370a74063edc46be3978747bf867 Mon Sep 17 00:00:00 2001 From: Kevin Mihelich Date: Thu, 18 Feb 2021 19:35:58 -0700 Subject: [PATCH 1/3] widevine support for arm @@ -8,7 +8,7 @@ Subject: [PATCH 1/3] widevine support for arm 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/third_party/widevine/cdm/widevine.gni b/third_party/widevine/cdm/widevine.gni -index b5821bf80a70f..bb49dca5f4664 100644 +index 4933cf6cdd2d5..37db4965c5b4c 100644 --- a/third_party/widevine/cdm/widevine.gni +++ b/third_party/widevine/cdm/widevine.gni @@ -26,7 +26,7 @@ if (is_chromeos && !is_chromeos_device) { @@ -18,8 +18,8 @@ index b5821bf80a70f..bb49dca5f4664 100644 - (target_os == "linux" && target_cpu == "x64") || + (target_os == "linux" && (target_cpu == "x64" || target_cpu == "arm" || target_cpu == "arm64")) || (target_os == "mac" && (target_cpu == "x64" || target_cpu == "arm64")) || - (target_os == "win" && (target_cpu == "x86" || target_cpu == "x64")) - + (target_os == "win" && + (target_cpu == "x86" || target_cpu == "x64" || target_cpu == "arm64")) -- -2.36.1 +2.37.0 diff --git a/extra/chromium/0002-Run-blink-bindings-generation-single-threaded.patch b/extra/chromium/0002-Run-blink-bindings-generation-single-threaded.patch index 9981b5d58..375469d50 100644 --- a/extra/chromium/0002-Run-blink-bindings-generation-single-threaded.patch +++ b/extra/chromium/0002-Run-blink-bindings-generation-single-threaded.patch @@ -1,4 +1,4 @@ -From fe03c5d7c0afccd13308e2f436bb06f5ac73c94c Mon Sep 17 00:00:00 2001 +From d067f01ffbea91b2714e91a59109813e05befbf7 Mon Sep 17 00:00:00 2001 From: Kevin Mihelich Date: Tue, 2 Feb 2021 13:58:59 -0700 Subject: [PATCH 2/3] Run blink bindings generation single threaded @@ -9,7 +9,7 @@ When not single threaded this process will eat all the RAM. 1 file changed, 1 insertion(+) diff --git a/third_party/blink/renderer/bindings/BUILD.gn b/third_party/blink/renderer/bindings/BUILD.gn -index 3b474c47dc7ce..e7787535882f9 100644 +index 354e106e46b77..d7ca31f2e1ace 100644 --- a/third_party/blink/renderer/bindings/BUILD.gn +++ b/third_party/blink/renderer/bindings/BUILD.gn @@ -148,6 +148,7 @@ template("generate_bindings") { @@ -21,5 +21,5 @@ index 3b474c47dc7ce..e7787535882f9 100644 rebase_path(web_idl_database, root_build_dir), "--root_src_dir", -- -2.36.1 +2.37.0 diff --git a/extra/chromium/0003-Fix-eu-strip-build-for-newer-GCC.patch b/extra/chromium/0003-Fix-eu-strip-build-for-newer-GCC.patch index c301e5410..af9c4122a 100644 --- a/extra/chromium/0003-Fix-eu-strip-build-for-newer-GCC.patch +++ b/extra/chromium/0003-Fix-eu-strip-build-for-newer-GCC.patch @@ -1,4 +1,4 @@ -From eedbf78a767be7161d58f4f1ae817f8db7fd5809 Mon Sep 17 00:00:00 2001 +From 4eb22fd6526566d7e51fd9070e2a58060cd02fa8 Mon Sep 17 00:00:00 2001 From: Kevin Mihelich Date: Wed, 21 Jul 2021 21:37:31 -0600 Subject: [PATCH 3/3] Fix eu-strip build for newer GCC @@ -693,5 +693,5 @@ index 86f2b67f6bbd1..c073e9a15827a 100755 cd build ../configure --enable-maintainer-mode -- -2.36.1 +2.37.0 diff --git a/extra/chromium/PKGBUILD b/extra/chromium/PKGBUILD index 7ff3aaa6a..385a5681a 100644 --- a/extra/chromium/PKGBUILD +++ b/extra/chromium/PKGBUILD @@ -15,11 +15,10 @@ highmem=1 pkgname=chromium -pkgver=103.0.5060.134 +pkgver=104.0.5112.79 pkgrel=1 _launcher_ver=8 -_gcc_patchset=4 -_manual_clone=0 +_gcc_patchset=2 pkgdesc="A web browser built for speed, simplicity, and security" arch=('x86_64') url="https://www.chromium.org/Home" @@ -37,30 +36,27 @@ options=('!lto') # Chromium adds its own flags for ThinLTO source=(https://commondatastorage.googleapis.com/chromium-browser-official/chromium-$pkgver.tar.xz https://github.com/foutrelis/chromium-launcher/archive/v$_launcher_ver/chromium-launcher-$_launcher_ver.tar.gz https://github.com/stha09/chromium-patches/releases/download/chromium-${pkgver%%.*}-patchset-$_gcc_patchset/chromium-${pkgver%%.*}-patchset-$_gcc_patchset.tar.xz + x11-ozone-fix-X11-screensaver-suspension.patch enable-GlobalMediaControlsCastStartStop.patch roll-src-third_party-ffmpeg.patch - sql-make-VirtualCursor-standard-layout-type.patch + chromium-tflite-system-zlib.patch remove-no-opaque-pointers-flag.patch use-oauth2-client-switches-as-default.patch 0001-widevine-support-for-arm.patch 0002-Run-blink-bindings-generation-single-threaded.patch 0003-Fix-eu-strip-build-for-newer-GCC.patch) -sha256sums=('e48a272481e41b1aae7aba71b55c41fe9e994cf71edd01c8ca1d0b604af0b571' +sha256sums=('9cc662f1a84c796521ee17ed2808795ca937fe7f77bc605e788f0304a81dabf3' '213e50f48b67feb4441078d50b0fd431df34323be15be97c55302d3fdac4483a' - 'fed11a8987d9f9baa04457fb114f8f7fdb800300a3780927020865bcc43e4f52' + 'ce702099849465927cf47f7bc3a4a27045d0e35e16b17481ebf35e14506bafa7' + '9956a843bc8a765c130080616ccd3ebc46ea95c3a2324c4b403bc293a8705eb2' '779fb13f2494209d3a7f1f23a823e59b9dded601866d3ab095937a1a04e19ac6' '30df59a9e2d95dcb720357ec4a83d9be51e59cc5551365da4c0073e68ccdec44' - 'b94b2e88f63cfb7087486508b8139599c89f96d7a4181c61fec4b4e250ca327a' - '00c16ce83ea4ca924a50fa0cfc2b2a4d744c722f363b065323e6ba0fcbac45a5' + '588c166bf748793758a7df438cfa665b32e09ca8fbd6380be28bc5984a33523c' + 'ab46b2c26a4dfe86486fd7e31bfc7211c515994a61a8c0cbd742f9c9e3c91873' 'e393174d7695d0bafed69e868c5fbfecf07aa6969f3b64596d0bae8b067e1711' - '765d78ba10af7a4dfbf7badb1c32a2b9b4a21941531a766ca2cdc0ff00425d01' - '4c79e4beac02269c864e69264ba6325ea809a5fefb8f48553bb2a610b1bb45f5' - '597083226fd762c8e4fd527d4ea2478b8cbf9180f12740efd9c6a1f4798a5d3a') - -if (( _manual_clone )); then - source[0]=fetch-chromium-release - makedepends+=('python-httplib2' 'python-pyparsing' 'python-six') -fi + '7fc0eb593ccb82ce2003ad32662e925f300a9042ef8d560ba437691c4fba12cf' + 'a2df732e49f7395fceda3acb781b1b3fc4d2826461b772a6cc9ce9dfe9c1e33a' + '601c57358026bd4dd31f075b445698ccb9b730b73a50ff2b46d64b1812ebb141') # Possible replacements are listed in build/linux/unbundle/replace_gn_files.py # Keys are the names in the above script; values are the dependencies in Arch @@ -98,9 +94,6 @@ depends+=(${_system_libs[@]}) _google_api_key=AIzaSyDwr302FpOSkGRpLlUpPThNTDPbXcIn_FM prepare() { - if (( _manual_clone )); then - ./fetch-chromium-release $pkgver - fi cd chromium-$pkgver # Allow building against system libraries in official builds @@ -135,6 +128,12 @@ prepare() { # Remove '-Xclang -no-opaque-pointers' flag not supported by our clang patch -Np1 -i ../remove-no-opaque-pointers-flag.patch + # Fix build with unbundled zlip (patch from Gentoo) + patch -Np1 -i ../chromium-tflite-system-zlib.patch + + # Upstream fixes + patch -Np1 -i ../x11-ozone-fix-X11-screensaver-suspension.patch + # Revert kGlobalMediaControlsCastStartStop enabled by default # https://crbug.com/1314342 patch -Rp1 -F3 -i ../enable-GlobalMediaControlsCastStartStop.patch @@ -143,11 +142,8 @@ prepare() { # https://crbug.com/1325301 patch -Rp1 -i ../roll-src-third_party-ffmpeg.patch - # https://chromium-review.googlesource.com/c/chromium/src/+/2862724 - patch -Np1 -i ../sql-make-VirtualCursor-standard-layout-type.patch - # Fixes for building with libstdc++ instead of libc++ - #patch -Np1 -i ../patches/ + patch -Np1 -i ../patches/chromium-103-VirtualCursor-std-layout.patch # Link to system tools required by the build mkdir -p third_party/node/linux/node-linux-x64/bin diff --git a/extra/chromium/chromium-tflite-system-zlib.patch b/extra/chromium/chromium-tflite-system-zlib.patch new file mode 100644 index 000000000..91ef5726b --- /dev/null +++ b/extra/chromium/chromium-tflite-system-zlib.patch @@ -0,0 +1,70 @@ +--- a/third_party/tflite_support/src/tensorflow_lite_support/metadata/cc/metadata_extractor.cc ++++ b/third_party/tflite_support/src/tensorflow_lite_support/metadata/cc/metadata_extractor.cc +@@ -21,8 +21,8 @@ limitations under the License. + #include "absl/status/status.h" // from @com_google_absl + #include "absl/strings/str_format.h" // from @com_google_absl + #include "absl/strings/string_view.h" // from @com_google_absl +-#include "contrib/minizip/ioapi.h" +-#include "contrib/minizip/unzip.h" ++#include "third_party/zlib/contrib/minizip/ioapi.h" ++#include "third_party/zlib/contrib/minizip/unzip.h" + #include "flatbuffers/flatbuffers.h" // from @flatbuffers + #include "tensorflow/lite/schema/schema_generated.h" + #include "tensorflow_lite_support/cc/common.h" +--- a/third_party/tflite_support/src/tensorflow_lite_support/metadata/cc/metadata_populator.cc ++++ b/third_party/tflite_support/src/tensorflow_lite_support/metadata/cc/metadata_populator.cc +@@ -19,8 +19,8 @@ limitations under the License. + #include + #include + +-#include "contrib/minizip/ioapi.h" +-#include "contrib/minizip/zip.h" ++#include "third_party/zlib/contrib/minizip/ioapi.h" ++#include "third_party/zlib/contrib/minizip/zip.h" + #include "flatbuffers/flatbuffers.h" // from @flatbuffers + #include "tensorflow/lite/schema/schema_generated.h" + #include "tensorflow_lite_support/cc/common.h" +--- a/third_party/tflite_support/src/tensorflow_lite_support/metadata/cc/utils/zip_readonly_mem_file.cc ++++ b/third_party/tflite_support/src/tensorflow_lite_support/metadata/cc/utils/zip_readonly_mem_file.cc +@@ -19,7 +19,7 @@ limitations under the License. + #include + + #include "absl/strings/string_view.h" // from @com_google_absl +-#include "contrib/minizip/ioapi.h" ++#include "third_party/zlib/contrib/minizip/ioapi.h" + + namespace tflite { + namespace metadata { +--- a/third_party/tflite_support/src/tensorflow_lite_support/metadata/cc/utils/zip_readonly_mem_file.h ++++ b/third_party/tflite_support/src/tensorflow_lite_support/metadata/cc/utils/zip_readonly_mem_file.h +@@ -19,7 +19,7 @@ limitations under the License. + #include + + #include "absl/strings/string_view.h" // from @com_google_absl +-#include "contrib/minizip/ioapi.h" ++#include "third_party/zlib/contrib/minizip/ioapi.h" + + namespace tflite { + namespace metadata { +--- a/third_party/tflite_support/src/tensorflow_lite_support/metadata/cc/utils/zip_writable_mem_file.cc ++++ b/third_party/tflite_support/src/tensorflow_lite_support/metadata/cc/utils/zip_writable_mem_file.cc +@@ -19,7 +19,7 @@ limitations under the License. + #include + + #include "absl/strings/string_view.h" // from @com_google_absl +-#include "contrib/minizip/ioapi.h" ++#include "third_party/zlib/contrib/minizip/ioapi.h" + + namespace tflite { + namespace metadata { +--- a/third_party/tflite_support/src/tensorflow_lite_support/metadata/cc/utils/zip_writable_mem_file.h ++++ b/third_party/tflite_support/src/tensorflow_lite_support/metadata/cc/utils/zip_writable_mem_file.h +@@ -19,7 +19,7 @@ limitations under the License. + #include + + #include "absl/strings/string_view.h" // from @com_google_absl +-#include "contrib/minizip/ioapi.h" ++#include "third_party/zlib/contrib/minizip/ioapi.h" + + namespace tflite { + namespace metadata { diff --git a/extra/chromium/fetch-chromium-release b/extra/chromium/fetch-chromium-release deleted file mode 100755 index f9bf0de2f..000000000 --- a/extra/chromium/fetch-chromium-release +++ /dev/null @@ -1,42 +0,0 @@ -#!/bin/bash - -set -e - -readonly VERSION=$1 -if [[ -z $VERSION ]]; then - echo >&2 'No version given as an argument' - exit 1 -fi - -mkdir chromium-checkout -cd chromium-checkout -cat >.gclient < -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 ---- - sql/recover_module/btree.cc | 18 ++++++++++++------ - sql/recover_module/btree.h | 21 +++++++++++++++------ - sql/recover_module/cursor.cc | 24 ++++++++++++------------ - sql/recover_module/cursor.h | 2 +- - sql/recover_module/pager.cc | 5 ++--- - sql/recover_module/pager.h | 6 +++--- - 6 files changed, 45 insertions(+), 31 deletions(-) - -diff --git a/sql/recover_module/btree.cc b/sql/recover_module/btree.cc -index cc9420e5c05..f12d8fa32a2 100644 ---- a/sql/recover_module/btree.cc -+++ b/sql/recover_module/btree.cc -@@ -136,16 +136,22 @@ static_assert(std::is_trivially_destructible::value, - "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 eaa087a5c52..df0e0c937c0 100644 ---- a/sql/recover_module/btree.h -+++ b/sql/recover_module/btree.h -@@ -101,9 +101,7 @@ class LeafPageDecoder { - 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 @@ class LeafPageDecoder { - // 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 @@ class LeafPageDecoder { - 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 4f827edf1b4..240de4999fe 100644 ---- a/sql/recover_module/cursor.cc -+++ b/sql/recover_module/cursor.cc -@@ -28,7 +28,7 @@ VirtualCursor::~VirtualCursor() { - 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 @@ int VirtualCursor::Next() { - 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 @@ int VirtualCursor::ReadColumn(int column_index, - 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 @@ void VirtualCursor::AppendPageDecoder(int page_id) { - return; - - if (LeafPageDecoder::IsOnValidPage(&db_reader_)) { -- leaf_decoder_ = std::make_unique(&db_reader_); -+ leaf_decoder_.Initialize(&db_reader_); - return; - } - -diff --git a/sql/recover_module/cursor.h b/sql/recover_module/cursor.h -index 845b7852648..cc4e85f83f9 100644 ---- a/sql/recover_module/cursor.h -+++ b/sql/recover_module/cursor.h -@@ -130,7 +130,7 @@ class VirtualCursor { - std::vector> inner_decoders_; - - // Decodes the leaf page containing records. -- std::unique_ptr leaf_decoder_; -+ LeafPageDecoder leaf_decoder_; - - SEQUENCE_CHECKER(sequence_checker_); - }; -diff --git a/sql/recover_module/pager.cc b/sql/recover_module/pager.cc -index 58e75de2704..69d98cef98d 100644 ---- a/sql/recover_module/pager.cc -+++ b/sql/recover_module/pager.cc -@@ -23,8 +23,7 @@ static_assert(DatabasePageReader::kMaxPageId <= std::numeric_limits::max(), - "ints are not appropriate for representing page IDs"); - - DatabasePageReader::DatabasePageReader(VirtualTable* table) -- : page_data_(std::make_unique(table->page_size())), -- table_(table) { -+ : page_data_(table->page_size()), table_(table) { - DCHECK(table != nullptr); - DCHECK(IsValidPageSize(table->page_size())); - } -@@ -58,7 +57,7 @@ int DatabasePageReader::ReadPage(int page_id) { - "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 07cac3cb989..d08f0932fab 100644 ---- a/sql/recover_module/pager.h -+++ b/sql/recover_module/pager.h -@@ -6,8 +6,8 @@ - #define SQL_RECOVER_MODULE_PAGER_H_ - - #include --#include - #include -+#include - - #include "base/check_op.h" - #include "base/memory/raw_ptr.h" -@@ -72,7 +72,7 @@ class DatabasePageReader { - 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 @@ class DatabasePageReader { - 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 page_data_; -+ std::vector page_data_; - // Raw pointer usage is acceptable because this instance's owner is expected - // to ensure that the VirtualTable outlives this. - const raw_ptr table_; diff --git a/extra/chromium/x11-ozone-fix-X11-screensaver-suspension.patch b/extra/chromium/x11-ozone-fix-X11-screensaver-suspension.patch new file mode 100644 index 000000000..4336d6a7a --- /dev/null +++ b/extra/chromium/x11-ozone-fix-X11-screensaver-suspension.patch @@ -0,0 +1,490 @@ +From 8c1ebea5f601b0b5247535dcdfd01755f3e6e1a6 Mon Sep 17 00:00:00 2001 +From: Andrew Wolfers +Date: Tue, 19 Jul 2022 15:01:25 +0000 +Subject: [PATCH] [x11][ozone] Fix X11 screensaver suspension. + +X11 screensaver suspension was broken by https://crrev.com/c/3507472, +in which usage patterns were migrated to a non-stacking paradigm. + +"Non-stacking" screensaver suspension describes an overriding behavior, +such that the last suspending or un-suspending call defines the current +state. Conversely, a "stacking" screensaver suspension paradigm allows +for parallel suspension, such that suspending calls are expected to be +matched by an equal number of un-suspending calls. + +Documentation for `PlatformScreen::SetScreenSaverSuspended` (inherited +by `X11ScreenOzone`) explains that it should be used in a non-stacking +manner [1], which contradicts the child class's underlying +implementation [2]. + +> If XScreenSaverSuspend is called multiple times with suspend set to +> 'True', it must be called an equal number of times with suspend set +> to 'False' in order for the screensaver timer to be restarted. + +This change updates the documentation/API of the `PlatformScreen` +parent class to correctly describe the stacking behavior of child class +`X11ScreenOzone`. This change also updates the implementation of +`WaylandScreen` to a stacking version. Lastly, this change updates the +call sites of `PlatformScreen` according to the API change. + +[1] https://crsrc.org/c/ui/ozone/public/platform_screen.h;l=96 +[2] https://linux.die.net/man/3/xscreensaverunsetattributes + +Bug: b:193670013 +Bug: b:196213351 +Bug: 1329573 +Bug: 1339361 +Change-Id: I60975c8da9f86a0f26f3c32cf49c4a7eeeea6a12 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3759067 +Commit-Queue: Andrew Wolfers +Reviewed-by: Thomas Anderson +Reviewed-by: Scott Violet +Cr-Commit-Position: refs/heads/main@{#1025717} + +(cherry picked from commit e61f08f8dbf1ec7cead427f3c497934e9d0db35f) +--- + ui/aura/screen_ozone.cc | 14 ++++++-- + ui/aura/screen_ozone.h | 29 ++++++++++++---- + ui/base/x/x11_util.h | 4 ++- + ui/display/screen.cc | 21 ++---------- + ui/display/screen.h | 34 ++++++------------- + .../platform/wayland/host/wayland_screen.cc | 31 +++++++++++++++++ + .../platform/wayland/host/wayland_screen.h | 30 +++++++++++++++- + ui/ozone/platform/x11/x11_screen_ozone.cc | 27 +++++++++++++-- + ui/ozone/platform/x11/x11_screen_ozone.h | 19 ++++++++++- + ui/ozone/public/platform_screen.cc | 8 +++-- + ui/ozone/public/platform_screen.h | 26 +++++++++++--- + 11 files changed, 182 insertions(+), 61 deletions(-) + +diff --git a/ui/aura/screen_ozone.cc b/ui/aura/screen_ozone.cc +index a78a6a48f1..09f62dc982 100644 +--- a/ui/aura/screen_ozone.cc ++++ b/ui/aura/screen_ozone.cc +@@ -4,6 +4,8 @@ + + #include "ui/aura/screen_ozone.h" + ++#include ++ + #include "ui/aura/client/screen_position_client.h" + #include "ui/aura/window.h" + #include "ui/aura/window_tree_host.h" +@@ -108,8 +110,16 @@ display::Display ScreenOzone::GetPrimaryDisplay() const { + } + + #if BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) +-bool ScreenOzone::SetScreenSaverSuspended(bool suspend) { +- return platform_screen_->SetScreenSaverSuspended(suspend); ++ScreenOzone::ScreenSaverSuspenderOzone::ScreenSaverSuspenderOzone( ++ std::unique_ptr suspender) ++ : suspender_(std::move(suspender)) {} ++ ++ScreenOzone::ScreenSaverSuspenderOzone::~ScreenSaverSuspenderOzone() = default; ++ ++std::unique_ptr ++ScreenOzone::SuspendScreenSaver() { ++ return std::make_unique( ++ platform_screen_->SuspendScreenSaver()); + } + #endif // BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) + +diff --git a/ui/aura/screen_ozone.h b/ui/aura/screen_ozone.h +index 2970a0e0e7..d033abf366 100644 +--- a/ui/aura/screen_ozone.h ++++ b/ui/aura/screen_ozone.h +@@ -11,10 +11,7 @@ + #include "build/chromeos_buildflags.h" + #include "ui/aura/aura_export.h" + #include "ui/display/screen.h" +- +-namespace ui { +-class PlatformScreen; +-} ++#include "ui/ozone/public/platform_screen.h" + + namespace aura { + +@@ -48,6 +45,10 @@ class AURA_EXPORT ScreenOzone : public display::Screen { + display::Display GetDisplayMatching( + const gfx::Rect& match_rect) const override; + display::Display GetPrimaryDisplay() const override; ++#if BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) ++ std::unique_ptr SuspendScreenSaver() ++ override; ++#endif // BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) + bool IsScreenSaverActive() const override; + base::TimeDelta CalculateIdleTime() const override; + void AddObserver(display::DisplayObserver* observer) override; +@@ -65,11 +66,27 @@ class AURA_EXPORT ScreenOzone : public display::Screen { + protected: + ui::PlatformScreen* platform_screen() { return platform_screen_.get(); } + ++ private: + #if BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) +- bool SetScreenSaverSuspended(bool suspend) override; ++ class ScreenSaverSuspenderOzone ++ : public display::Screen::ScreenSaverSuspender { ++ public: ++ explicit ScreenSaverSuspenderOzone( ++ std::unique_ptr ++ suspender); ++ ++ ScreenSaverSuspenderOzone(const ScreenSaverSuspenderOzone&) = delete; ++ ScreenSaverSuspenderOzone& operator=(const ScreenSaverSuspenderOzone&) = ++ delete; ++ ++ ~ScreenSaverSuspenderOzone() override; ++ ++ private: ++ std::unique_ptr ++ suspender_; ++ }; + #endif // BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) + +- private: + gfx::AcceleratedWidget GetAcceleratedWidgetForWindow( + aura::Window* window) const; + +diff --git a/ui/base/x/x11_util.h b/ui/base/x/x11_util.h +index bf36efe170..0692571582 100644 +--- a/ui/base/x/x11_util.h ++++ b/ui/base/x/x11_util.h +@@ -337,7 +337,9 @@ COMPONENT_EXPORT(UI_BASE_X) bool IsCompositingManagerPresent(); + COMPONENT_EXPORT(UI_BASE_X) bool IsX11WindowFullScreen(x11::Window window); + + // Suspends or resumes the X screen saver, and returns whether the operation was +-// successful. Must be called on the UI thread. ++// successful. Must be called on the UI thread. If called multiple times with ++// |suspend| set to true, the screen saver is not un-suspended until this method ++// is called an equal number of times with |suspend| set to false. + COMPONENT_EXPORT(UI_BASE_X) bool SuspendX11ScreenSaver(bool suspend); + + // Returns true if the window manager supports the given hint. +diff --git a/ui/display/screen.cc b/ui/display/screen.cc +index b9723889ce..70dc0a9f5c 100644 +--- a/ui/display/screen.cc ++++ b/ui/display/screen.cc +@@ -85,26 +85,11 @@ void Screen::SetDisplayForNewWindows(int64_t display_id) { + } + + #if BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) +-std::unique_ptr Screen::SuspendScreenSaver() { +- SetScreenSaverSuspended(true); +- screen_saver_suspension_count_++; +- return base::WrapUnique(new Screen::ScreenSaverSuspender(this)); +-} +- +-Screen::ScreenSaverSuspender::~ScreenSaverSuspender() { +- // Check that this suspender still refers to the active screen. Particularly +- // in tests, the screen might be destructed before the suspender. +- if (screen_ == GetScreen()) { +- screen_->screen_saver_suspension_count_--; +- if (screen_->screen_saver_suspension_count_ == 0) { +- screen_->SetScreenSaverSuspended(false); +- } +- } +-} ++Screen::ScreenSaverSuspender::~ScreenSaverSuspender() = default; + +-bool Screen::SetScreenSaverSuspended(bool suspend) { ++std::unique_ptr Screen::SuspendScreenSaver() { + NOTIMPLEMENTED_LOG_ONCE(); +- return false; ++ return nullptr; + } + #endif // BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) + +diff --git a/ui/display/screen.h b/ui/display/screen.h +index a86c5b63cc..d04534006f 100644 +--- a/ui/display/screen.h ++++ b/ui/display/screen.h +@@ -133,28 +133,22 @@ class DISPLAY_EXPORT Screen { + // its existence. + class ScreenSaverSuspender { + public: +- ScreenSaverSuspender(const Screen&) = delete; +- ScreenSaverSuspender& operator=(const Screen&) = delete; ++ ScreenSaverSuspender() = default; + +- // Notifies |screen_| that this instance is being destructed, and causes its +- // platform-specific screensaver to be un-suspended if this is the last such +- // remaining instance. +- ~ScreenSaverSuspender(); ++ ScreenSaverSuspender(const ScreenSaverSuspender&) = delete; ++ ScreenSaverSuspender& operator=(const ScreenSaverSuspender&) = delete; + +- private: +- friend class Screen; +- +- explicit ScreenSaverSuspender(Screen* screen) : screen_(screen) {} +- +- Screen* screen_; ++ // Causes the platform-specific screensaver to be un-suspended iff this is ++ // the last remaining instance. ++ virtual ~ScreenSaverSuspender() = 0; + }; + + // Suspends the platform-specific screensaver until the returned +- // |ScreenSaverSuspender| is destructed. This method allows stacking multiple +- // overlapping calls, such that the platform-specific screensaver will not be +- // un-suspended until all returned |SreenSaverSuspender| instances have been +- // destructed. +- std::unique_ptr SuspendScreenSaver(); ++ // |ScreenSaverSuspender| is destructed, or returns nullptr if suspension ++ // failed. This method allows stacking multiple overlapping calls, such that ++ // the platform-specific screensaver will not be un-suspended until all ++ // returned |ScreenSaverSuspender| instances have been destructed. ++ virtual std::unique_ptr SuspendScreenSaver(); + #endif // BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) + + // Returns whether the screensaver is currently running. +@@ -200,12 +194,6 @@ class DISPLAY_EXPORT Screen { + const gfx::GpuExtraInfo& gpu_extra_info); + + protected: +-#if BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) +- // Suspends or un-suspends the platform-specific screensaver, and returns +- // whether the operation was successful. +- virtual bool SetScreenSaverSuspended(bool suspend); +-#endif // BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) +- + void set_shutdown(bool shutdown) { shutdown_ = shutdown; } + + private: +diff --git a/ui/ozone/platform/wayland/host/wayland_screen.cc b/ui/ozone/platform/wayland/host/wayland_screen.cc +index 0c7dc5c02b..18cd81b472 100644 +--- a/ui/ozone/platform/wayland/host/wayland_screen.cc ++++ b/ui/ozone/platform/wayland/host/wayland_screen.cc +@@ -327,6 +327,37 @@ display::Display WaylandScreen::GetDisplayMatching( + return display_matching ? *display_matching : GetPrimaryDisplay(); + } + ++std::unique_ptr ++WaylandScreen::WaylandScreenSaverSuspender::Create(WaylandScreen& screen) { ++ auto suspender = base::WrapUnique(new WaylandScreenSaverSuspender(screen)); ++ if (suspender->is_suspending_) { ++ screen.screen_saver_suspension_count_++; ++ return suspender; ++ } ++ ++ return nullptr; ++} ++ ++WaylandScreen::WaylandScreenSaverSuspender::WaylandScreenSaverSuspender( ++ WaylandScreen& screen) ++ : screen_(screen.GetWeakPtr()) { ++ is_suspending_ = screen.SetScreenSaverSuspended(true); ++} ++ ++WaylandScreen::WaylandScreenSaverSuspender::~WaylandScreenSaverSuspender() { ++ if (screen_ && is_suspending_) { ++ screen_->screen_saver_suspension_count_--; ++ if (screen_->screen_saver_suspension_count_ == 0) { ++ screen_->SetScreenSaverSuspended(false); ++ } ++ } ++} ++ ++std::unique_ptr ++WaylandScreen::SuspendScreenSaver() { ++ return WaylandScreenSaverSuspender::Create(*this); ++} ++ + bool WaylandScreen::SetScreenSaverSuspended(bool suspend) { + if (!connection_->zwp_idle_inhibit_manager()) + return false; +diff --git a/ui/ozone/platform/wayland/host/wayland_screen.h b/ui/ozone/platform/wayland/host/wayland_screen.h +index 87358f4f06..8e5515104a 100644 +--- a/ui/ozone/platform/wayland/host/wayland_screen.h ++++ b/ui/ozone/platform/wayland/host/wayland_screen.h +@@ -68,7 +68,8 @@ class WaylandScreen : public PlatformScreen { + const gfx::Point& point) const override; + display::Display GetDisplayMatching( + const gfx::Rect& match_rect) const override; +- bool SetScreenSaverSuspended(bool suspend) override; ++ std::unique_ptr ++ SuspendScreenSaver() override; + bool IsScreenSaverActive() const override; + base::TimeDelta CalculateIdleTime() const override; + void AddObserver(display::DisplayObserver* observer) override; +@@ -76,7 +77,33 @@ class WaylandScreen : public PlatformScreen { + std::vector GetGpuExtraInfo( + const gfx::GpuExtraInfo& gpu_extra_info) override; + ++ protected: ++ // Suspends or un-suspends the platform-specific screensaver, and returns ++ // whether the operation was successful. Can be called more than once with the ++ // same value for |suspend|, but those states should not stack: the first ++ // alternating value should toggle the state of the suspend. ++ bool SetScreenSaverSuspended(bool suspend); ++ + private: ++ class WaylandScreenSaverSuspender ++ : public PlatformScreen::PlatformScreenSaverSuspender { ++ public: ++ WaylandScreenSaverSuspender(const WaylandScreenSaverSuspender&) = delete; ++ WaylandScreenSaverSuspender& operator=(const WaylandScreenSaverSuspender&) = ++ delete; ++ ++ ~WaylandScreenSaverSuspender() override; ++ ++ static std::unique_ptr Create( ++ WaylandScreen& screen); ++ ++ private: ++ explicit WaylandScreenSaverSuspender(WaylandScreen& screen); ++ ++ base::WeakPtr screen_; ++ bool is_suspending_ = false; ++ }; ++ + // All parameters are in DIP screen coordinates/units except |physical_size|, + // which is in physical pixels. + void AddOrUpdateDisplay(uint32_t output_id, +@@ -103,6 +130,7 @@ class WaylandScreen : public PlatformScreen { + #endif + + wl::Object idle_inhibitor_; ++ uint32_t screen_saver_suspension_count_ = 0; + + base::WeakPtrFactory weak_factory_; + }; +diff --git a/ui/ozone/platform/x11/x11_screen_ozone.cc b/ui/ozone/platform/x11/x11_screen_ozone.cc +index 53265ab58a..b450df9c83 100644 +--- a/ui/ozone/platform/x11/x11_screen_ozone.cc ++++ b/ui/ozone/platform/x11/x11_screen_ozone.cc +@@ -4,6 +4,8 @@ + + #include "ui/ozone/platform/x11/x11_screen_ozone.h" + ++#include ++ + #include "base/containers/flat_set.h" + #include "ui/base/linux/linux_desktop.h" + #include "ui/base/x/x11_idle_query.h" +@@ -131,8 +133,29 @@ display::Display X11ScreenOzone::GetDisplayMatching( + return matching_display ? *matching_display : GetPrimaryDisplay(); + } + +-bool X11ScreenOzone::SetScreenSaverSuspended(bool suspend) { +- return SuspendX11ScreenSaver(suspend); ++X11ScreenOzone::X11ScreenSaverSuspender::X11ScreenSaverSuspender() { ++ is_suspending_ = SuspendX11ScreenSaver(true); ++} ++ ++std::unique_ptr ++X11ScreenOzone::X11ScreenSaverSuspender::Create() { ++ auto suspender = base::WrapUnique(new X11ScreenSaverSuspender()); ++ if (suspender->is_suspending_) { ++ return suspender; ++ } ++ ++ return nullptr; ++} ++ ++X11ScreenOzone::X11ScreenSaverSuspender::~X11ScreenSaverSuspender() { ++ if (is_suspending_) { ++ SuspendX11ScreenSaver(false); ++ } ++} ++ ++std::unique_ptr ++X11ScreenOzone::SuspendScreenSaver() { ++ return X11ScreenSaverSuspender::Create(); + } + + bool X11ScreenOzone::IsScreenSaverActive() const { +diff --git a/ui/ozone/platform/x11/x11_screen_ozone.h b/ui/ozone/platform/x11/x11_screen_ozone.h +index d86acae9aa..81e0fd13d8 100644 +--- a/ui/ozone/platform/x11/x11_screen_ozone.h ++++ b/ui/ozone/platform/x11/x11_screen_ozone.h +@@ -50,7 +50,8 @@ class X11ScreenOzone : public PlatformScreen, + const gfx::Point& point) const override; + display::Display GetDisplayMatching( + const gfx::Rect& match_rect) const override; +- bool SetScreenSaverSuspended(bool suspend) override; ++ std::unique_ptr ++ SuspendScreenSaver() override; + bool IsScreenSaverActive() const override; + base::TimeDelta CalculateIdleTime() const override; + void AddObserver(display::DisplayObserver* observer) override; +@@ -66,6 +67,22 @@ class X11ScreenOzone : public PlatformScreen, + private: + friend class X11ScreenOzoneTest; + ++ class X11ScreenSaverSuspender ++ : public PlatformScreen::PlatformScreenSaverSuspender { ++ public: ++ X11ScreenSaverSuspender(const X11ScreenSaverSuspender&) = delete; ++ X11ScreenSaverSuspender& operator=(const X11ScreenSaverSuspender&) = delete; ++ ++ ~X11ScreenSaverSuspender() override; ++ ++ static std::unique_ptr Create(); ++ ++ private: ++ X11ScreenSaverSuspender(); ++ ++ bool is_suspending_ = false; ++ }; ++ + // Overridden from ui::XDisplayManager::Delegate: + void OnXDisplayListUpdated() override; + float GetXDisplayScaleFactor() const override; +diff --git a/ui/ozone/public/platform_screen.cc b/ui/ozone/public/platform_screen.cc +index 98f599aa41..2353208396 100644 +--- a/ui/ozone/public/platform_screen.cc ++++ b/ui/ozone/public/platform_screen.cc +@@ -30,9 +30,13 @@ std::string PlatformScreen::GetCurrentWorkspace() { + return {}; + } + +-bool PlatformScreen::SetScreenSaverSuspended(bool suspend) { ++PlatformScreen::PlatformScreenSaverSuspender::~PlatformScreenSaverSuspender() = ++ default; ++ ++std::unique_ptr ++PlatformScreen::SuspendScreenSaver() { + NOTIMPLEMENTED_LOG_ONCE(); +- return false; ++ return nullptr; + } + + bool PlatformScreen::IsScreenSaverActive() const { +diff --git a/ui/ozone/public/platform_screen.h b/ui/ozone/public/platform_screen.h +index 091220a99f..e4adfafce3 100644 +--- a/ui/ozone/public/platform_screen.h ++++ b/ui/ozone/public/platform_screen.h +@@ -89,11 +89,27 @@ class COMPONENT_EXPORT(OZONE_BASE) PlatformScreen { + virtual display::Display GetDisplayMatching( + const gfx::Rect& match_rect) const = 0; + +- // Suspends or un-suspends the platform-specific screensaver, and returns +- // whether the operation was successful. Can be called more than once with the +- // same value for |suspend|, but those states should not stack: the first +- // alternating value should toggle the state of the suspend. +- virtual bool SetScreenSaverSuspended(bool suspend); ++ // Object which suspends the platform-specific screensaver for the duration of ++ // its existence. ++ class PlatformScreenSaverSuspender { ++ public: ++ PlatformScreenSaverSuspender() = default; ++ ++ PlatformScreenSaverSuspender(const PlatformScreenSaverSuspender&) = delete; ++ PlatformScreenSaverSuspender& operator=( ++ const PlatformScreenSaverSuspender&) = delete; ++ ++ // Causes the platform-specific screensaver to be un-suspended iff this is ++ // the last remaining instance. ++ virtual ~PlatformScreenSaverSuspender() = 0; ++ }; ++ ++ // Suspends the platform-specific screensaver until the returned ++ // |PlatformScreenSaverSuspender| is destructed, or returns nullptr if ++ // suspension failed. This method allows stacking multiple overlapping calls, ++ // such that the platform-specific screensaver will not be un-suspended until ++ // all returned |PlatformScreenSaverSuspender| instances have been destructed. ++ virtual std::unique_ptr SuspendScreenSaver(); + + // Returns whether the screensaver is currently running. + virtual bool IsScreenSaverActive() const;