upgpkg: ungoogled-chromium 104.0.5112.79-1

upstream release

7 files changed, 596 insertions, 267 deletions

diff --git a/.SRCINFO b/.SRCINFO
index 1418d14..518a7a8 100644
--- a/.SRCINFO
+++ b/.SRCINFO
@@ -1,6 +1,6 @@
 pkgbase = ungoogled-chromium
 	pkgdesc = A lightweight approach to removing Google web service dependency
-	pkgver = 103.0.5060.134
+	pkgver = 104.0.5112.79
 	pkgrel = 1
 	url = https://github.com/ungoogled-software/ungoogled-chromium
 	arch = x86_64
@@ -53,26 +53,28 @@ pkgbase = ungoogled-chromium
 	conflicts = chromium
 	options = debug
 	options = !lto
-	source = https://commondatastorage.googleapis.com/chromium-browser-official/chromium-103.0.5060.134.tar.xz
+	source = https://commondatastorage.googleapis.com/chromium-browser-official/chromium-104.0.5112.79.tar.xz
 	source = https://github.com/foutrelis/chromium-launcher/archive/v8/chromium-launcher-8.tar.gz
-	source = https://github.com/stha09/chromium-patches/releases/download/chromium-103-patchset-4/chromium-103-patchset-4.tar.xz
+	source = https://github.com/stha09/chromium-patches/releases/download/chromium-104-patchset-2/chromium-104-patchset-2.tar.xz
+	source = x11-ozone-fix-X11-screensaver-suspension.patch
 	source = enable-GlobalMediaControlsCastStartStop.patch
 	source = roll-src-third_party-ffmpeg.patch
-	source = sql-make-VirtualCursor-standard-layout-type.patch
+	source = chromium-tflite-system-zlib.patch
 	source = remove-no-opaque-pointers-flag.patch
 	source = use-oauth2-client-switches-as-default.patch
-	source = ungoogled-chromium-103.0.5060.134-1.tar.gz::https://github.com/ungoogled-software/ungoogled-chromium/archive/103.0.5060.134-1.tar.gz
+	source = ungoogled-chromium-104.0.5112.79-1.tar.gz::https://github.com/ungoogled-software/ungoogled-chromium/archive/refs/tags/104.0.5112.79-1.tar.gz
 	source = chromium-drirc-disable-10bpc-color-configs.conf
 	source = ozone-add-va-api-support-to-wayland.patch
-	sha256sums = e48a272481e41b1aae7aba71b55c41fe9e994cf71edd01c8ca1d0b604af0b571
+	sha256sums = 9cc662f1a84c796521ee17ed2808795ca937fe7f77bc605e788f0304a81dabf3
 	sha256sums = 213e50f48b67feb4441078d50b0fd431df34323be15be97c55302d3fdac4483a
-	sha256sums = fed11a8987d9f9baa04457fb114f8f7fdb800300a3780927020865bcc43e4f52
+	sha256sums = ce702099849465927cf47f7bc3a4a27045d0e35e16b17481ebf35e14506bafa7
+	sha256sums = 9956a843bc8a765c130080616ccd3ebc46ea95c3a2324c4b403bc293a8705eb2
 	sha256sums = 779fb13f2494209d3a7f1f23a823e59b9dded601866d3ab095937a1a04e19ac6
 	sha256sums = 30df59a9e2d95dcb720357ec4a83d9be51e59cc5551365da4c0073e68ccdec44
-	sha256sums = b94b2e88f63cfb7087486508b8139599c89f96d7a4181c61fec4b4e250ca327a
-	sha256sums = 00c16ce83ea4ca924a50fa0cfc2b2a4d744c722f363b065323e6ba0fcbac45a5
+	sha256sums = 588c166bf748793758a7df438cfa665b32e09ca8fbd6380be28bc5984a33523c
+	sha256sums = ab46b2c26a4dfe86486fd7e31bfc7211c515994a61a8c0cbd742f9c9e3c91873
 	sha256sums = e393174d7695d0bafed69e868c5fbfecf07aa6969f3b64596d0bae8b067e1711
-	sha256sums = da6cac43b587a88032760ebebada96b10bb1a170a451e22a507b48aae2e977ec
+	sha256sums = 75fbb5a8679522cd81520a5623e18d8aa4783d5403d2bc26aacab90d899a7a15
 	sha256sums = babda4f5c1179825797496898d77334ac067149cac03d797ab27ac69671a7feb
 	sha256sums = af20fc58aef22dd0b1fb560a1fab68d0d27187ff18fad7eb1670feab9bc4a8d8
 
diff --git a/PKGBUILD b/PKGBUILD
index 7265083..9c91836 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -9,10 +9,10 @@
 # Contributor: Daniel J Griffiths <ghost1227@archlinux.us>
 
 pkgname=ungoogled-chromium
-pkgver=103.0.5060.134
+pkgver=104.0.5112.79
 pkgrel=1
 _launcher_ver=8
-_gcc_patchset=4
+_gcc_patchset=2
 pkgdesc="A lightweight approach to removing Google web service dependency"
 arch=('x86_64')
 url="https://github.com/ungoogled-software/ungoogled-chromium"
@@ -30,29 +30,31 @@ options=('debug' '!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)
-sha256sums=('e48a272481e41b1aae7aba71b55c41fe9e994cf71edd01c8ca1d0b604af0b571'
+sha256sums=('9cc662f1a84c796521ee17ed2808795ca937fe7f77bc605e788f0304a81dabf3'
             '213e50f48b67feb4441078d50b0fd431df34323be15be97c55302d3fdac4483a'
-            'fed11a8987d9f9baa04457fb114f8f7fdb800300a3780927020865bcc43e4f52'
+            'ce702099849465927cf47f7bc3a4a27045d0e35e16b17481ebf35e14506bafa7'
+            '9956a843bc8a765c130080616ccd3ebc46ea95c3a2324c4b403bc293a8705eb2'
             '779fb13f2494209d3a7f1f23a823e59b9dded601866d3ab095937a1a04e19ac6'
             '30df59a9e2d95dcb720357ec4a83d9be51e59cc5551365da4c0073e68ccdec44'
-            'b94b2e88f63cfb7087486508b8139599c89f96d7a4181c61fec4b4e250ca327a'
-            '00c16ce83ea4ca924a50fa0cfc2b2a4d744c722f363b065323e6ba0fcbac45a5'
+            '588c166bf748793758a7df438cfa665b32e09ca8fbd6380be28bc5984a33523c'
+            'ab46b2c26a4dfe86486fd7e31bfc7211c515994a61a8c0cbd742f9c9e3c91873'
             'e393174d7695d0bafed69e868c5fbfecf07aa6969f3b64596d0bae8b067e1711')
 provides=('chromium')
 conflicts=('chromium')
 _uc_usr=ungoogled-software
 _uc_ver=$pkgver-1
 source=(${source[@]}
-        $pkgname-$_uc_ver.tar.gz::https://github.com/$_uc_usr/ungoogled-chromium/archive/$_uc_ver.tar.gz
+        $pkgname-$_uc_ver.tar.gz::https://github.com/$_uc_usr/ungoogled-chromium/archive/refs/tags/$_uc_ver.tar.gz
         chromium-drirc-disable-10bpc-color-configs.conf
         ozone-add-va-api-support-to-wayland.patch)
 sha256sums=(${sha256sums[@]}
-            'da6cac43b587a88032760ebebada96b10bb1a170a451e22a507b48aae2e977ec'
+            '75fbb5a8679522cd81520a5623e18d8aa4783d5403d2bc26aacab90d899a7a15'
             'babda4f5c1179825797496898d77334ac067149cac03d797ab27ac69671a7feb'
             'af20fc58aef22dd0b1fb560a1fab68d0d27187ff18fad7eb1670feab9bc4a8d8')
  
@@ -104,6 +106,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
@@ -112,11 +120,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
 
   # Enable vaapi on wayland
   patch -Np1 -i ../ozone-add-va-api-support-to-wayland.patch
diff --git a/chromium-tflite-system-zlib.patch b/chromium-tflite-system-zlib.patch
new file mode 100644
index 0000000..91ef572
--- /dev/null
+++ b/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 <cstring>
+ #include <functional>
+ 
+-#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 <cstdio>
+ 
+ #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 <cstdlib>
+ 
+ #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 <cstdio>
+ 
+ #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 <cstdlib>
+ 
+ #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/remove-no-opaque-pointers-flag.patch b/remove-no-opaque-pointers-flag.patch
index a8eba73..9bd434a 100644
--- a/remove-no-opaque-pointers-flag.patch
+++ b/remove-no-opaque-pointers-flag.patch
@@ -1,12 +1,12 @@
---- chromium-102.0.5005.61/build/config/compiler/BUILD.gn.orig	2022-05-19 10:35:52.991415777 +0000
-+++ chromium-102.0.5005.61/build/config/compiler/BUILD.gn	2022-05-19 10:36:11.102017131 +0000
-@@ -1538,15 +1538,6 @@ config("default_warnings") {
-         cflags += [ "-Wno-deprecated-non-prototype" ]
+--- chromium-104.0.5112.57/build/config/compiler/BUILD.gn.orig	2022-07-26 08:11:54.192788877 +0000
++++ chromium-104.0.5112.57/build/config/compiler/BUILD.gn	2022-07-26 08:12:10.019328155 +0000
+@@ -1540,15 +1540,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
+-        # TODO(https://crbug.com/1322823): Remove flags once potential miscompile is investigated.
 -        cflags += [
 -          "-Xclang",
 -          "-no-opaque-pointers",
diff --git a/sql-make-VirtualCursor-standard-layout-type.patch b/sql-make-VirtualCursor-standard-layout-type.patch
deleted file mode 100644
index 3364d41..0000000
--- a/sql-make-VirtualCursor-standard-layout-type.patch
+++ /dev/null
@@ -1,238 +0,0 @@
-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
----
- 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<LeafPageDecoder>::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<LeafPageDecoder>(&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<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 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<int>::max(),
-               "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 @@ 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 <cstdint>
--#include <memory>
- #include <ostream>
-+#include <vector>
- 
- #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<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/update-patches.sh b/update-patches.sh
index 8ca3cbe..506f394 100755
--- a/update-patches.sh
+++ b/update-patches.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
 mkdir tmp
-mv wayland-egl.patch ozone-add-va-api-support-to-wayland.patch tmp
+mv ozone-add-va-api-support-to-wayland.patch tmp
 
 rm *.patch
 git clone https://github.com/archlinux/svntogit-packages.git --branch packages/chromium --single-branch chr
diff --git a/x11-ozone-fix-X11-screensaver-suspension.patch b/x11-ozone-fix-X11-screensaver-suspension.patch
new file mode 100644
index 0000000..4336d6a
--- /dev/null
+++ b/x11-ozone-fix-X11-screensaver-suspension.patch
@@ -0,0 +1,490 @@
+From 8c1ebea5f601b0b5247535dcdfd01755f3e6e1a6 Mon Sep 17 00:00:00 2001
+From: Andrew Wolfers <aswolfers@chromium.org>
+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 <aswolfers@chromium.org>
+Reviewed-by: Thomas Anderson <thomasanderson@chromium.org>
+Reviewed-by: Scott Violet <sky@chromium.org>
+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 <memory>
++
+ #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<ui::PlatformScreen::PlatformScreenSaverSuspender> suspender)
++    : suspender_(std::move(suspender)) {}
++
++ScreenOzone::ScreenSaverSuspenderOzone::~ScreenSaverSuspenderOzone() = default;
++
++std::unique_ptr<display::Screen::ScreenSaverSuspender>
++ScreenOzone::SuspendScreenSaver() {
++  return std::make_unique<ScreenSaverSuspenderOzone>(
++      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<display::Screen::ScreenSaverSuspender> 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<ui::PlatformScreen::PlatformScreenSaverSuspender>
++            suspender);
++
++    ScreenSaverSuspenderOzone(const ScreenSaverSuspenderOzone&) = delete;
++    ScreenSaverSuspenderOzone& operator=(const ScreenSaverSuspenderOzone&) =
++        delete;
++
++    ~ScreenSaverSuspenderOzone() override;
++
++   private:
++    std::unique_ptr<ui::PlatformScreen::PlatformScreenSaverSuspender>
++        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::ScreenSaverSuspender> 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::ScreenSaverSuspender> 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<ScreenSaverSuspender> 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<ScreenSaverSuspender> 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>
++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<PlatformScreen::PlatformScreenSaverSuspender>
++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<PlatformScreen::PlatformScreenSaverSuspender>
++  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<base::Value> 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<WaylandScreenSaverSuspender> Create(
++        WaylandScreen& screen);
++
++   private:
++    explicit WaylandScreenSaverSuspender(WaylandScreen& screen);
++
++    base::WeakPtr<WaylandScreen> 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<zwp_idle_inhibitor_v1> idle_inhibitor_;
++  uint32_t screen_saver_suspension_count_ = 0;
+ 
+   base::WeakPtrFactory<WaylandScreen> 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 <memory>
++
+ #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>
++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<PlatformScreen::PlatformScreenSaverSuspender>
++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<PlatformScreen::PlatformScreenSaverSuspender>
++  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<X11ScreenSaverSuspender> 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::PlatformScreenSaverSuspender>
++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<PlatformScreenSaverSuspender> SuspendScreenSaver();
+ 
+   // Returns whether the screensaver is currently running.
+   virtual bool IsScreenSaverActive() const;