From 4521cd66d56ecf32606226a372a6781250b04ca7 Mon Sep 17 00:00:00 2001 From: Duncaen Date: Mon, 1 Aug 2022 15:22:29 +0200 Subject: [PATCH] chromium: update to 104.0.5112.79. --- .../musl-patches/quiche-arena-size.patch | 4 +- .../remove-no-opaque-pointers-flag.patch | 4 +- ...ozone-fix-X11-screensaver-suspension.patch | 490 ++++++++++++++++++ .../patches/xxx-ppc64le-4k-pages.patch | 10 +- srcpkgs/chromium/template | 15 +- 5 files changed, 508 insertions(+), 15 deletions(-) create mode 100644 srcpkgs/chromium/patches/x11-ozone-fix-X11-screensaver-suspension.patch diff --git a/srcpkgs/chromium/files/musl-patches/quiche-arena-size.patch b/srcpkgs/chromium/files/musl-patches/quiche-arena-size.patch index 1c9182dbc810..c2cb489b246b 100644 --- a/srcpkgs/chromium/files/musl-patches/quiche-arena-size.patch +++ b/srcpkgs/chromium/files/musl-patches/quiche-arena-size.patch @@ -1,10 +1,10 @@ --- ./net/third_party/quiche/src/quiche/quic/core/quic_one_block_arena.h +++ ./net/third_party/quiche/src/quiche/quic/core/quic_one_block_arena.h -@@ -69,7 +69,7 @@ +@@ -70,7 +70,7 @@ // QuicConnections currently use around 1KB of polymorphic types which would // ordinarily be on the heap. Instead, store them inline in an arena. --using QuicConnectionArena = QuicOneBlockArena<1248>; +-using QuicConnectionArena = QuicOneBlockArena<1280>; +using QuicConnectionArena = QuicOneBlockArena<1504>; } // namespace quic diff --git a/srcpkgs/chromium/patches/remove-no-opaque-pointers-flag.patch b/srcpkgs/chromium/patches/remove-no-opaque-pointers-flag.patch index a8eba730836e..1231eeb7def0 100644 --- a/srcpkgs/chromium/patches/remove-no-opaque-pointers-flag.patch +++ b/srcpkgs/chromium/patches/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" ] + 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/srcpkgs/chromium/patches/x11-ozone-fix-X11-screensaver-suspension.patch b/srcpkgs/chromium/patches/x11-ozone-fix-X11-screensaver-suspension.patch new file mode 100644 index 000000000000..4336d6a7a0a4 --- /dev/null +++ b/srcpkgs/chromium/patches/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; diff --git a/srcpkgs/chromium/patches/xxx-ppc64le-4k-pages.patch b/srcpkgs/chromium/patches/xxx-ppc64le-4k-pages.patch index 953ca165a094..886be0bf4666 100644 --- a/srcpkgs/chromium/patches/xxx-ppc64le-4k-pages.patch +++ b/srcpkgs/chromium/patches/xxx-ppc64le-4k-pages.patch @@ -13,9 +13,9 @@ diff --git a/base/allocator/partition_allocator/page_allocator_constants.h b/bas index bfd5753..045082b 100644 --- a/base/allocator/partition_allocator/page_allocator_constants.h +++ b/base/allocator/partition_allocator/page_allocator_constants.h -@@ -40,7 +40,7 @@ namespace base { +@@ -69,7 +69,7 @@ namespace base { - PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t + PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE size_t PageAllocationGranularityShift() { -#if BUILDFLAG(IS_WIN) || defined(ARCH_CPU_PPC64) +#if BUILDFLAG(IS_WIN) @@ -26,18 +26,18 @@ diff --git a/base/allocator/partition_allocator/partition_alloc_constants.h b/ba index 0b9260d..3e054ec 100644 --- a/base/allocator/partition_allocator/partition_alloc_constants.h +++ b/base/allocator/partition_allocator/partition_alloc_constants.h -@@ -74,11 +74,6 @@ +@@ -90,11 +90,6 @@ PartitionPageShift() { return 16; // 64 KiB } -#elif defined(ARCH_CPU_PPC64) --PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t +-PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE size_t -PartitionPageShift() { - return 18; // 256 KiB -} #elif (BUILDFLAG(IS_APPLE) && defined(ARCH_CPU_64_BITS)) || \ (BUILDFLAG(IS_LINUX) && defined(ARCH_CPU_ARM64)) - PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t + PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE size_t diff --git a/base/allocator/partition_allocator/partition_alloc_forward.h b/base/allocator/partition_allocator/partition_alloc_forward.h index 938ea38..9414b41 100644 --- a/base/allocator/partition_allocator/partition_alloc_forward.h diff --git a/srcpkgs/chromium/template b/srcpkgs/chromium/template index e6e0d1298b9b..b8d3e2512978 100644 --- a/srcpkgs/chromium/template +++ b/srcpkgs/chromium/template @@ -1,7 +1,7 @@ # Template file for 'chromium' pkgname=chromium # See https://chromiumdash.appspot.com/releases?platform=Linux for the latest version -version=103.0.5060.134 +version=104.0.5112.79 revision=1 archs="i686* x86_64* aarch64* armv7l* ppc64le*" short_desc="Google's attempt at creating a safer, faster, and more stable browser" @@ -9,7 +9,7 @@ maintainer="Duncaen " license="BSD-3-Clause" homepage="https://www.chromium.org/" distfiles="https://commondatastorage.googleapis.com/chromium-browser-official/${pkgname}-${version}.tar.xz" -checksum=e48a272481e41b1aae7aba71b55c41fe9e994cf71edd01c8ca1d0b604af0b571 +checksum=9cc662f1a84c796521ee17ed2808795ca937fe7f77bc605e788f0304a81dabf3 lib32disabled=yes @@ -20,10 +20,10 @@ desc_option_debug="Build with debug symbols" desc_option_js_optimize="Optimize the JS used for Chromium's UI" desc_option_pipewire="Enable support for screen sharing for WebRTC via PipeWire" -hostmakedepends="$(vopt_if clang "clang lld llvm12") python python3 pkgconf perl gperf bison ninja nodejs hwids +hostmakedepends="$(vopt_if clang "clang lld llvm12") python3 pkgconf perl gperf bison ninja nodejs hwids libatomic-devel libevent-devel libglib-devel $(vopt_if js_optimize openjdk) wayland-devel libepoxy-devel git" -makedepends="libpng-devel gtk+-devel gtk+3-devel nss-devel pciutils-devel - libXi-devel libgcrypt-devel libgnome-keyring-devel cups-devel elfutils-devel +makedepends="libpng-devel gtk+3-devel nss-devel pciutils-devel + libXi-devel libgcrypt-devel cups-devel elfutils-devel libXcomposite-devel speech-dispatcher-devel libXrandr-devel mit-krb5-devel libXScrnSaver-devel alsa-lib-devel snappy-devel libdrm-devel libxml2-devel libxslt-devel $(vopt_if pulseaudio pulseaudio-devel) libexif-devel @@ -31,7 +31,7 @@ makedepends="libpng-devel gtk+-devel gtk+3-devel nss-devel pciutils-devel libjpeg-turbo-devel libevent-devel json-c-devel minizip-devel jsoncpp-devel zlib-devel libcap-devel libXdamage-devel re2-devel fontconfig-devel freetype-devel opus-devel libatomic-devel - ffmpeg-devel libva-devel python-setuptools xcb-proto libcurl-devel + ffmpeg-devel libva-devel xcb-proto libcurl-devel libxshmfence-devel $(vopt_if pipewire pipewire-devel) $(vopt_if sndio sndio-devel)" depends="libexif hwids desktop-file-utils hicolor-icon-theme xdg-utils" @@ -240,6 +240,9 @@ do_configure() { "use_vaapi=$(vopt_if vaapi true false)" + # deprecated + 'use_gnome_keyring=false' + # https://chromium.googlesource.com/chromium/src/+/master/docs/closure_compilation.md "enable_js_type_check=$(vopt_if js_optimize true false)"