Date: Tue, 16 Aug 2022 19:20:05 GMT From: Rene Ladan <rene@FreeBSD.org> To: ports-committers@FreeBSD.org, dev-commits-ports-all@FreeBSD.org, dev-commits-ports-branches@FreeBSD.org Subject: git: 53b38e91865a - 2022Q3 - www/chromium: two fixes from upstream Message-ID: <202208161920.27GJK5ka004713@gitrepo.freebsd.org>
next in thread | raw e-mail | index | archive | help
The branch 2022Q3 has been updated by rene: URL: https://cgit.FreeBSD.org/ports/commit/?id=53b38e91865aa83f30c798135ed923377354610b commit 53b38e91865aa83f30c798135ed923377354610b Author: Robert Nagy <robert@openbsd.org> AuthorDate: 2022-08-15 16:50:19 +0000 Commit: Rene Ladan <rene@FreeBSD.org> CommitDate: 2022-08-16 19:19:58 +0000 www/chromium: two fixes from upstream - std::is_same compiler error - X11 screensaver suspension commit 904c8cedf85c7223f96ea084953089fea9a36bdd Author: Ben Noordhuis <info@bnoordhuis.nl> Date: Thu Jul 07 10:28:11 2022 Fix std::is_same compiler error 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. (cherry picked from commit b108b8734f8256503267fd05c48c7bc22f033beb) --- www/chromium/Makefile | 1 + www/chromium/files/patch-ui_aura_screen__ozone.cc | 29 ++++++- www/chromium/files/patch-ui_aura_screen__ozone.h | 52 +++++++++++- www/chromium/files/patch-ui_base_x_x11__util.h | 13 +++ www/chromium/files/patch-ui_display_screen.cc | 33 ++++++-- www/chromium/files/patch-ui_display_screen.h | 57 +++++++++++-- ..._ozone_platform_wayland_host_wayland__screen.cc | 40 +++++++++ ...i_ozone_platform_wayland_host_wayland__screen.h | 54 ++++++++++++ ...tch-ui_ozone_platform_x11_x11__screen__ozone.cc | 43 ++++++++++ ...atch-ui_ozone_platform_x11_x11__screen__ozone.h | 35 ++++++++ .../patch-ui_ozone_public_platform__screen.cc | 18 ++++ .../files/patch-ui_ozone_public_platform__screen.h | 35 ++++++++ www/chromium/files/patch-v8_src_objects_simd.cc | 99 ++++++++++++++++++++++ 13 files changed, 489 insertions(+), 20 deletions(-) diff --git a/www/chromium/Makefile b/www/chromium/Makefile index 105000c1e678..e98ecb723010 100644 --- a/www/chromium/Makefile +++ b/www/chromium/Makefile @@ -1,5 +1,6 @@ PORTNAME= chromium PORTVERSION= 104.0.5112.79 +PORTREVISION= 1 CATEGORIES= www wayland MASTER_SITES= https://commondatastorage.googleapis.com/chromium-browser-official/ \ https://nerd.hu/distfiles/:external diff --git a/www/chromium/files/patch-ui_aura_screen__ozone.cc b/www/chromium/files/patch-ui_aura_screen__ozone.cc index 407604a9484c..95bea0388bb1 100644 --- a/www/chromium/files/patch-ui_aura_screen__ozone.cc +++ b/www/chromium/files/patch-ui_aura_screen__ozone.cc @@ -1,11 +1,32 @@ ---- ui/aura/screen_ozone.cc.orig 2022-07-22 17:30:31 UTC +--- ui/aura/screen_ozone.cc.orig 2022-08-15 13:11:31 UTC +++ ui/aura/screen_ozone.cc -@@ -107,7 +107,7 @@ display::Display ScreenOzone::GetPrimaryDisplay() cons +@@ -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" +@@ -107,9 +109,17 @@ display::Display ScreenOzone::GetPrimaryDisplay() cons return platform_screen_->GetPrimaryDisplay(); } -#if BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) +-bool ScreenOzone::SetScreenSaverSuspended(bool suspend) { +- return platform_screen_->SetScreenSaverSuspended(suspend); +#if BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD) - 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/www/chromium/files/patch-ui_aura_screen__ozone.h b/www/chromium/files/patch-ui_aura_screen__ozone.h index c34014971143..536fc0ed5cd2 100644 --- a/www/chromium/files/patch-ui_aura_screen__ozone.h +++ b/www/chromium/files/patch-ui_aura_screen__ozone.h @@ -1,11 +1,57 @@ ---- ui/aura/screen_ozone.h.orig 2022-07-22 17:30:31 UTC +--- ui/aura/screen_ozone.h.orig 2022-08-15 13:11:31 UTC +++ ui/aura/screen_ozone.h -@@ -65,7 +65,7 @@ class AURA_EXPORT ScreenOzone : public display::Screen +@@ -11,11 +11,8 @@ + #include "build/chromeos_buildflags.h" + #include "ui/aura/aura_export.h" + #include "ui/display/screen.h" ++#include "ui/ozone/public/platform_screen.h" + +-namespace ui { +-class PlatformScreen; +-} +- + namespace aura { + + // display::Screen implementation on top of ui::PlatformScreen provided by +@@ -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) || BUILDFLAG(IS_BSD) ++ 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(); } -#if BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) +- bool SetScreenSaverSuspended(bool suspend) override; ++ private: +#if BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD) - 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/www/chromium/files/patch-ui_base_x_x11__util.h b/www/chromium/files/patch-ui_base_x_x11__util.h new file mode 100644 index 000000000000..0d6634107a84 --- /dev/null +++ b/www/chromium/files/patch-ui_base_x_x11__util.h @@ -0,0 +1,13 @@ +--- ui/base/x/x11_util.h.orig 2022-08-15 13:11:31 UTC ++++ ui/base/x/x11_util.h +@@ -337,7 +337,9 @@ COMPONENT_EXPORT(UI_BASE_X) bool IsCompositingManagerP + 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/www/chromium/files/patch-ui_display_screen.cc b/www/chromium/files/patch-ui_display_screen.cc index 77ea0c0b4224..ef832b6d1b8f 100644 --- a/www/chromium/files/patch-ui_display_screen.cc +++ b/www/chromium/files/patch-ui_display_screen.cc @@ -1,11 +1,34 @@ ---- ui/display/screen.cc.orig 2022-07-22 17:30:31 UTC +--- ui/display/screen.cc.orig 2022-08-15 13:11:31 UTC +++ ui/display/screen.cc -@@ -84,7 +84,7 @@ void Screen::SetDisplayForNewWindows(int64_t display_i +@@ -84,27 +84,12 @@ void Screen::SetDisplayForNewWindows(int64_t display_i display_id_for_new_windows_ = 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)); +-} +#if BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD) - std::unique_ptr<Screen::ScreenSaverSuspender> Screen::SuspendScreenSaver() { - SetScreenSaverSuspended(true); - screen_saver_suspension_count_++; ++Screen::ScreenSaverSuspender::~ScreenSaverSuspender() = default; + +-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); +- } +- } +-} +- +-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/www/chromium/files/patch-ui_display_screen.h b/www/chromium/files/patch-ui_display_screen.h index 0c68f862a44f..7156108d309d 100644 --- a/www/chromium/files/patch-ui_display_screen.h +++ b/www/chromium/files/patch-ui_display_screen.h @@ -1,6 +1,6 @@ ---- ui/display/screen.h.orig 2022-07-22 17:30:31 UTC +--- ui/display/screen.h.orig 2022-08-15 13:11:31 UTC +++ ui/display/screen.h -@@ -128,7 +128,7 @@ class DISPLAY_EXPORT Screen { +@@ -128,33 +128,27 @@ class DISPLAY_EXPORT Screen { // (both of which may or may not be `nearest_id`). display::ScreenInfos GetScreenInfosNearestDisplay(int64_t nearest_id) const; @@ -9,16 +9,57 @@ // Object which suspends the platform-specific screensaver for the duration of // its existence. class ScreenSaverSuspender { -@@ -200,7 +200,7 @@ class DISPLAY_EXPORT Screen { + 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) -+#if BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD) - // Suspends or un-suspends the platform-specific screensaver, and returns - // whether the operation was successful. - virtual bool SetScreenSaverSuspended(bool suspend); -@@ -224,7 +224,7 @@ class DISPLAY_EXPORT Screen { +- // 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: +@@ -224,7 +212,7 @@ class DISPLAY_EXPORT Screen { int64_t display_id_for_new_windows_; int64_t scoped_display_id_for_new_windows_ = display::kInvalidDisplayId; diff --git a/www/chromium/files/patch-ui_ozone_platform_wayland_host_wayland__screen.cc b/www/chromium/files/patch-ui_ozone_platform_wayland_host_wayland__screen.cc new file mode 100644 index 000000000000..89b58cdfc90b --- /dev/null +++ b/www/chromium/files/patch-ui_ozone_platform_wayland_host_wayland__screen.cc @@ -0,0 +1,40 @@ +--- ui/ozone/platform/wayland/host/wayland_screen.cc.orig 2022-08-15 13:11:31 UTC ++++ 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/www/chromium/files/patch-ui_ozone_platform_wayland_host_wayland__screen.h b/www/chromium/files/patch-ui_ozone_platform_wayland_host_wayland__screen.h new file mode 100644 index 000000000000..e4d48c6286c0 --- /dev/null +++ b/www/chromium/files/patch-ui_ozone_platform_wayland_host_wayland__screen.h @@ -0,0 +1,54 @@ +--- ui/ozone/platform/wayland/host/wayland_screen.h.orig 2022-08-15 13:11:31 UTC ++++ 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/www/chromium/files/patch-ui_ozone_platform_x11_x11__screen__ozone.cc b/www/chromium/files/patch-ui_ozone_platform_x11_x11__screen__ozone.cc new file mode 100644 index 000000000000..a3fcbadc62c7 --- /dev/null +++ b/www/chromium/files/patch-ui_ozone_platform_x11_x11__screen__ozone.cc @@ -0,0 +1,43 @@ +--- ui/ozone/platform/x11/x11_screen_ozone.cc.orig 2022-08-15 13:11:31 UTC ++++ 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" +@@ -135,8 +137,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/www/chromium/files/patch-ui_ozone_platform_x11_x11__screen__ozone.h b/www/chromium/files/patch-ui_ozone_platform_x11_x11__screen__ozone.h new file mode 100644 index 000000000000..20d4e6641f98 --- /dev/null +++ b/www/chromium/files/patch-ui_ozone_platform_x11_x11__screen__ozone.h @@ -0,0 +1,35 @@ +--- ui/ozone/platform/x11/x11_screen_ozone.h.orig 2022-08-15 13:11:31 UTC ++++ 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; +@@ -65,6 +66,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; diff --git a/www/chromium/files/patch-ui_ozone_public_platform__screen.cc b/www/chromium/files/patch-ui_ozone_public_platform__screen.cc new file mode 100644 index 000000000000..4c44f74009a2 --- /dev/null +++ b/www/chromium/files/patch-ui_ozone_public_platform__screen.cc @@ -0,0 +1,18 @@ +--- ui/ozone/public/platform_screen.cc.orig 2022-08-15 13:11:31 UTC ++++ 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/www/chromium/files/patch-ui_ozone_public_platform__screen.h b/www/chromium/files/patch-ui_ozone_public_platform__screen.h new file mode 100644 index 000000000000..072b90d5de2c --- /dev/null +++ b/www/chromium/files/patch-ui_ozone_public_platform__screen.h @@ -0,0 +1,35 @@ +--- ui/ozone/public/platform_screen.h.orig 2022-08-15 13:11:31 UTC ++++ 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; diff --git a/www/chromium/files/patch-v8_src_objects_simd.cc b/www/chromium/files/patch-v8_src_objects_simd.cc new file mode 100644 index 000000000000..0da0ff0b7948 --- /dev/null +++ b/www/chromium/files/patch-v8_src_objects_simd.cc @@ -0,0 +1,99 @@ +--- v8/src/objects/simd.cc.orig 2022-08-06 09:56:20 UTC ++++ v8/src/objects/simd.cc +@@ -151,10 +151,15 @@ inline int extract_first_nonzero_index(float64x2_t v) + template <typename T> + inline uintptr_t fast_search_noavx(T* array, uintptr_t array_len, + uintptr_t index, T search_element) { +- static_assert(std::is_same<T, uint32_t>::value || +- std::is_same<T, uint64_t>::value || +- std::is_same<T, double>::value); ++ static constexpr bool is_uint32 = ++ sizeof(T) == sizeof(uint32_t) && std::is_integral<T>::value; ++ static constexpr bool is_uint64 = ++ sizeof(T) == sizeof(uint64_t) && std::is_integral<T>::value; ++ static constexpr bool is_double = ++ sizeof(T) == sizeof(double) && std::is_floating_point<T>::value; + ++ static_assert(is_uint32 || is_uint64 || is_double); ++ + #if !(defined(__SSE3__) || defined(NEON64)) + // No SIMD available. + return slow_search(array, array_len, index, search_element); +@@ -181,14 +186,14 @@ inline uintptr_t fast_search_noavx(T* array, uintptr_t + + // Inserting one of the vectorized loop + #ifdef __SSE3__ +- if constexpr (std::is_same<T, uint32_t>::value) { ++ if constexpr (is_uint32) { + #define MOVEMASK(x) _mm_movemask_ps(_mm_castsi128_ps(x)) + #define EXTRACT(x) base::bits::CountTrailingZeros32(x) + VECTORIZED_LOOP_x86(__m128i, __m128i, _mm_set1_epi32, _mm_cmpeq_epi32, + MOVEMASK, EXTRACT) + #undef MOVEMASK + #undef EXTRACT +- } else if constexpr (std::is_same<T, uint64_t>::value) { ++ } else if constexpr (is_double) { + #define SET1(x) _mm_castsi128_ps(_mm_set1_epi64x(x)) + #define CMP(a, b) _mm_cmpeq_pd(_mm_castps_pd(a), _mm_castps_pd(b)) + #define EXTRACT(x) base::bits::CountTrailingZeros32(x) +@@ -203,13 +208,13 @@ inline uintptr_t fast_search_noavx(T* array, uintptr_t + #undef EXTRACT + } + #elif defined(NEON64) +- if constexpr (std::is_same<T, uint32_t>::value) { ++ if constexpr (is_uint32) { + VECTORIZED_LOOP_Neon(int32x4_t, int32x4_t, vdupq_n_u32, vceqq_u32, + vmaxvq_u32) +- } else if constexpr (std::is_same<T, uint64_t>::value) { ++ } else if constexpr (is_uint64) { + VECTORIZED_LOOP_Neon(int64x2_t, int64x2_t, vdupq_n_u64, vceqq_u64, + vmaxvq_u32) +- } else if constexpr (std::is_same<T, double>::value) { ++ } else if constexpr (is_double) { + VECTORIZED_LOOP_Neon(float64x2_t, float64x2_t, vdupq_n_f64, vceqq_f64, + vmaxvq_f64) + } +@@ -243,10 +248,15 @@ template <typename T> + TARGET_AVX2 inline uintptr_t fast_search_avx(T* array, uintptr_t array_len, + uintptr_t index, + T search_element) { +- static_assert(std::is_same<T, uint32_t>::value || +- std::is_same<T, uint64_t>::value || +- std::is_same<T, double>::value); ++ static constexpr bool is_uint32 = ++ sizeof(T) == sizeof(uint32_t) && std::is_integral<T>::value; ++ static constexpr bool is_uint64 = ++ sizeof(T) == sizeof(uint64_t) && std::is_integral<T>::value; ++ static constexpr bool is_double = ++ sizeof(T) == sizeof(double) && std::is_floating_point<T>::value; + ++ static_assert(is_uint32 || is_uint64 || is_double); ++ + const int target_align = 32; + // Scalar loop to reach desired alignment + for (; +@@ -259,21 +269,21 @@ TARGET_AVX2 inline uintptr_t fast_search_avx(T* array, + } + + // Generating vectorized loop +- if constexpr (std::is_same<T, uint32_t>::value) { ++ if constexpr (is_uint32) { + #define MOVEMASK(x) _mm256_movemask_ps(_mm256_castsi256_ps(x)) + #define EXTRACT(x) base::bits::CountTrailingZeros32(x) + VECTORIZED_LOOP_x86(__m256i, __m256i, _mm256_set1_epi32, _mm256_cmpeq_epi32, + MOVEMASK, EXTRACT) + #undef MOVEMASK + #undef EXTRACT +- } else if constexpr (std::is_same<T, uint64_t>::value) { ++ } else if constexpr (is_uint64) { + #define MOVEMASK(x) _mm256_movemask_pd(_mm256_castsi256_pd(x)) + #define EXTRACT(x) base::bits::CountTrailingZeros32(x) + VECTORIZED_LOOP_x86(__m256i, __m256i, _mm256_set1_epi64x, + _mm256_cmpeq_epi64, MOVEMASK, EXTRACT) + #undef MOVEMASK + #undef EXTRACT +- } else if constexpr (std::is_same<T, double>::value) { ++ } else if constexpr (is_double) { + #define CMP(a, b) _mm256_cmp_pd(a, b, _CMP_EQ_OQ) + #define EXTRACT(x) base::bits::CountTrailingZeros32(x) + VECTORIZED_LOOP_x86(__m256d, __m256d, _mm256_set1_pd, CMP,
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?202208161920.27GJK5ka004713>