Date: Thursday, January 5, 2023 @ 20:24:04 Author: archange Revision: 1378354
Versionned electron 20.x package Added: electron20/ electron20/repos/ electron20/trunk/ electron20/trunk/PKGBUILD electron20/trunk/chromium-tflite-system-zlib.patch electron20/trunk/default_app-icon.patch electron20/trunk/electron-launcher.sh electron20/trunk/electron.desktop electron20/trunk/jinja-python-3.10.patch electron20/trunk/remove-no-opaque-pointers-flag.patch electron20/trunk/roll-src-third_party-ffmpeg.patch electron20/trunk/std-vector-non-const.patch electron20/trunk/use-system-libraries-in-node.patch electron20/trunk/x11-ozone-fix-X11-screensaver-suspension.patch ------------------------------------------------+ PKGBUILD | 302 ++++++++++++++ chromium-tflite-system-zlib.patch | 70 +++ default_app-icon.patch | 21 electron-launcher.sh | 20 electron.desktop | 7 jinja-python-3.10.patch | 22 + remove-no-opaque-pointers-flag.patch | 18 roll-src-third_party-ffmpeg.patch | 333 +++++++++++++++ std-vector-non-const.patch | 109 +++++ use-system-libraries-in-node.patch | 53 ++ x11-ozone-fix-X11-screensaver-suspension.patch | 490 +++++++++++++++++++++++ 11 files changed, 1445 insertions(+) Added: electron20/trunk/PKGBUILD =================================================================== --- electron20/trunk/PKGBUILD (rev 0) +++ electron20/trunk/PKGBUILD 2023-01-05 20:24:04 UTC (rev 1378354) @@ -0,0 +1,302 @@ +# Maintainer: Bruno Pagani <[email protected]> + +_use_suffix=1 +pkgver=20.3.8 +_commit=9fa958cb5fa02fbca258f8b6894d5371bf6e4415 +_chromiumver=104.0.5112.124 +_gcc_patchset=2 +# shellcheck disable=SC2034 +pkgrel=1 + +_major_ver=${pkgver%%.*} +if [[ ${_use_suffix} != 0 ]]; then + pkgname="electron${_major_ver}" +else + pkgname=electron +fi +# shellcheck disable=SC2034 +pkgdesc='Build cross platform desktop apps with web technologies' +# shellcheck disable=SC2034 +arch=('x86_64') +# shellcheck disable=SC2034 +url='https://electronjs.org/' +# shellcheck disable=SC2034 +license=('MIT' 'custom') +# shellcheck disable=SC2034 +depends=('c-ares' 'ffmpeg' 'gtk3' 'libevent' 'libxslt' 'minizip' 'nss' 're2' + 'snappy') +# shellcheck disable=SC2034 +makedepends=('clang' 'git' 'gn' 'gperf' 'harfbuzz-icu' 'http-parser' + 'java-runtime-headless' 'jsoncpp' 'libnotify' 'lld' 'llvm' 'ninja' + 'npm' 'pciutils' 'pipewire' 'python' 'python-httplib2' + 'python-pyparsing' 'python-six' 'wget' 'yarn') +# shellcheck disable=SC2034 +optdepends=('kde-cli-tools: file deletion support (kioclient5)' + 'libappindicator-gtk3: StatusNotifierItem support' + 'pipewire: WebRTC desktop sharing under Wayland' + 'trash-cli: file deletion support (trash-put)' + 'xdg-utils: open URLs with desktop’s default (xdg-email, xdg-open)') +if [[ ${_use_suffix} == 0 ]]; then + # shellcheck disable=SC2034 + conflicts=("electron${_major_ver}") + # shellcheck disable=SC2034 + provides=("electron${_major_ver}") +fi +# shellcheck disable=SC2034 +options=('!lto') # Electron adds its own flags for ThinLTO +# shellcheck disable=SC2034 +source=('git+https://github.com/electron/electron.git' + 'git+https://chromium.googlesource.com/chromium/tools/depot_tools.git#branch=main' + "https://github.com/stha09/chromium-patches/releases/download/chromium-${_chromiumver%%.*}-patchset-${_gcc_patchset}/chromium-${_chromiumver%%.*}-patchset-${_gcc_patchset}.tar.xz"; + "electron-launcher.sh" + "electron.desktop" + 'default_app-icon.patch' + 'jinja-python-3.10.patch' + 'use-system-libraries-in-node.patch' + 'std-vector-non-const.patch' + 'x11-ozone-fix-X11-screensaver-suspension.patch' + 'roll-src-third_party-ffmpeg.patch' + 'chromium-tflite-system-zlib.patch' + 'remove-no-opaque-pointers-flag.patch' + ) +# shellcheck disable=SC2034 +sha256sums=('SKIP' + 'SKIP' + 'ce702099849465927cf47f7bc3a4a27045d0e35e16b17481ebf35e14506bafa7' + '77817939c9833f8dda74a8c75620c15747170551ffa6f14f7c5b4071599e8831' + '4484200d90b76830b69eea3a471c103999a3ce86bb2c29e6c14c945bf4102bae' + 'dd2d248831dd4944d385ebf008426e66efe61d6fdf66f8932c963a12167947b4' + '55dbe71dbc1f3ab60bf1fa79f7aea7ef1fe76436b1d7df48728a1f8227d2134e' + 'c70652a8b24c237bcfd27469de32797a2cb46d9f0d63d897bb6418314a25644c' + '76b969e1534e8c355b8b524a686cbf3b24136eaa6bd40b0c09fdd9866049f159' + '9956a843bc8a765c130080616ccd3ebc46ea95c3a2324c4b403bc293a8705eb2' + '30df59a9e2d95dcb720357ec4a83d9be51e59cc5551365da4c0073e68ccdec44' + '588c166bf748793758a7df438cfa665b32e09ca8fbd6380be28bc5984a33523c' + 'ab46b2c26a4dfe86486fd7e31bfc7211c515994a61a8c0cbd742f9c9e3c91873') + +_system_libs=('ffmpeg' + 'flac' + 'fontconfig' + 'freetype' + 'harfbuzz-ng' + 'icu' + 'libdrm' + 'libevent' + 'libjpeg' + 'libpng' +# 'libvpx' + 'libwebp' + 'libxml' + 'libxslt' +# 'openh264' + 'opus' + 're2' + 'snappy' + 'zlib' + ) + +prepare() { + sed -i "s|@ELECTRON@|${pkgname}|" electron-launcher.sh + sed -i "s|@ELECTRON@|${pkgname}|" electron.desktop + if [[ ${_use_suffix} != 0 ]]; then + sed -i "s|@ELECTRON_NAME@|Electron ${_major_ver}|" electron.desktop + else + sed -i "s|@ELECTRON_NAME@|Electron|" electron.desktop + fi + + export PATH="${PATH}:${srcdir:?}/depot_tools" + + echo "Fetching chromium..." + git clone --branch=${_chromiumver} --depth=1 \ + https://chromium.googlesource.com/chromium/src.git + + echo "solutions = [ + { + \"name\": \"src/electron\", + \"url\": \"file://${srcdir}/electron@${_commit}\", + \"deps_file\": \"DEPS\", + \"managed\": False, + \"custom_deps\": { + \"src\": None, + }, + \"custom_vars\": {}, + }, +]" > .gclient + + python "${srcdir}/depot_tools/gclient.py" sync \ + --with_branch_heads \ + --with_tags \ + --nohooks + + ( + cd src/electron || exit + patch -Np1 -i ../../std-vector-non-const.patch + ) + + echo "Running hooks..." + # python "${srcdir}/depot_tools/gclient.py" runhooks + src/build/landmines.py + src/build/util/lastchange.py -o src/build/util/LASTCHANGE + src/build/util/lastchange.py -m GPU_LISTS_VERSION \ + --revision-id-only --header src/gpu/config/gpu_lists_version.h + src/build/util/lastchange.py -m SKIA_COMMIT_HASH \ + -s src/third_party/skia --header src/skia/ext/skia_commit_hash.h + # Create sysmlink to system clang-format + ln -s /usr/bin/clang-format src/buildtools/linux64 + # Create sysmlink to system Node.js + mkdir -p src/third_party/node/linux/node-linux-x64/bin + ln -sf /usr/bin/node src/third_party/node/linux/node-linux-x64/bin + src/third_party/depot_tools/download_from_google_storage.py \ + --no_resume --extract --no_auth --bucket chromium-nodejs \ + -s src/third_party/node/node_modules.tar.gz.sha1 + python src/tools/download_optimization_profile.py \ + --newest_state=src/chrome/android/profiles/newest.txt \ + --local_state=src/chrome/android/profiles/local.txt \ + --output_name=src/chrome/android/profiles/afdo.prof \ + --gs_url_base=chromeos-prebuilt/afdo-job/llvm + #vpython src/tools/update_pgo_profiles.py \ + # --target=linux \ + # update \ + # --gs-url-base=chromium-optimization-profiles/pgo_profiles + src/electron/script/apply_all_patches.py \ + src/electron/patches/config.json + cd src/electron || exit + yarn install --frozen-lockfile + cd .. + + echo "Applying local patches..." + # 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 ffmpeg roll requiring new channel layout API support + # https://crbug.com/1325301 + patch -Rp1 -i ../roll-src-third_party-ffmpeg.patch + + # Fixes for building with libstdc++ instead of libc++ + patch -Np1 -i ../patches/chromium-103-VirtualCursor-std-layout.patch + + # Electron specific fixes + patch -d third_party/electron_node/tools/inspector_protocol/jinja2 \ + -Np1 -i ../../../../../../jinja-python-3.10.patch + patch -Np1 -i ../use-system-libraries-in-node.patch + patch -Np1 -i ../default_app-icon.patch # Icon from .desktop file + + echo "Patching Chromium for using system libraries..." + sed -i 's/OFFICIAL_BUILD/GOOGLE_CHROME_BUILD/' \ + tools/generate_shim_headers/generate_shim_headers.py + for lib in $(printf "%s\n" "${_system_libs[@]}" | sed 's/^libjpeg$/&_turbo/'); do + third_party_dir="third_party/${lib}" + if [ ! -d "${third_party_dir}" ]; then + third_party_dir="base/${third_party_dir}" + fi + find "${third_party_dir}" -type f \ + \! -path "${third_party_dir}/chromium/*" \ + \! -path "${third_party_dir}/google/*" \ + \! -path 'third_party/harfbuzz-ng/utils/hb_scoped.h' \ + \! -regex '.*\.\(gn\|gni\|isolate\)' \ + -delete + done + build/linux/unbundle/replace_gn_files.py \ + --system-libraries \ + "${_system_libs[@]}" +} + +build() { + export CC=clang + export CXX=clang++ + export AR=ar + export NM=nm + + # https://github.com/webpack/webpack/issues/14532 + export NODE_OPTIONS=--openssl-legacy-provider + + # Facilitate deterministic builds (taken from build/config/compiler/BUILD.gn) + CFLAGS+=' -Wno-builtin-macro-redefined' + CXXFLAGS+=' -Wno-builtin-macro-redefined' + CPPFLAGS+=' -D__DATE__= -D__TIME__= -D__TIMESTAMP__=' + + # Do not warn about unknown warning options + CFLAGS+=' -Wno-unknown-warning-option' + CXXFLAGS+=' -Wno-unknown-warning-option' + + # Let Chromium set its own symbol level + CFLAGS=${CFLAGS/-g } + CXXFLAGS=${CXXFLAGS/-g } + + # https://github.com/ungoogled-software/ungoogled-chromium-archlinux/issues/123 + CFLAGS=${CFLAGS/-fexceptions} + CFLAGS=${CFLAGS/-fcf-protection} + CXXFLAGS=${CXXFLAGS/-fexceptions} + CXXFLAGS=${CXXFLAGS/-fcf-protection} + + # This appears to cause random segfaults when combined with ThinLTO + # https://bugs.archlinux.org/task/73518 + CFLAGS=${CFLAGS/-fstack-clash-protection} + CXXFLAGS=${CXXFLAGS/-fstack-clash-protection} + + # https://crbug.com/957519#c122 + CXXFLAGS=${CXXFLAGS/-Wp,-D_GLIBCXX_ASSERTIONS} + + # Do not warn about unknown warning options + CFLAGS+=' -Wno-unknown-warning-option' + CXXFLAGS+=' -Wno-unknown-warning-option' + + cd src || exit + export CHROMIUM_BUILDTOOLS_PATH="${PWD}/buildtools" + GN_EXTRA_ARGS=' + custom_toolchain = "//build/toolchain/linux/unbundle:default" + host_toolchain = "//build/toolchain/linux/unbundle:default" + clang_use_chrome_plugins = false + symbol_level = 0 + chrome_pgo_phase = 0 + treat_warnings_as_errors = false + rtc_use_pipewire = true + link_pulseaudio = true + use_gnome_keyring = false + use_sysroot = false + use_custom_libcxx = false + icu_use_data_file = false + is_component_ffmpeg = false + ' + gn gen out/Release \ + --args="import(\"//electron/build/args/release.gn\") ${GN_EXTRA_ARGS}" + ninja -C out/Release electron + # Strip before zip to avoid + # zipfile.LargeZipFile: Filesize would require ZIP64 extensions + strip -s out/Release/electron + ninja -C out/Release electron_dist_zip + # ninja -C out/Release third_party/electron_node:headers +} + +package() { + install -dm755 "${pkgdir:?}/usr/lib/${pkgname}" + bsdtar -xf src/out/Release/dist.zip -C "${pkgdir}/usr/lib/${pkgname}" + + chmod u+s "${pkgdir}/usr/lib/${pkgname}/chrome-sandbox" + + install -dm755 "${pkgdir}/usr/share/licenses/${pkgname}" + for l in "${pkgdir}/usr/lib/${pkgname}"/{LICENSE,LICENSES.chromium.html}; do + ln -s \ + "$(realpath --relative-to="${pkgdir}/usr/share/licenses/${pkgname}" "${l}")" \ + "${pkgdir}/usr/share/licenses/${pkgname}" + done + + install -Dm755 "${srcdir}/electron-launcher.sh" \ + "${pkgdir}/usr/bin/${pkgname}" + if [[ "${_use_suffix}" == 0 ]]; then + ln -s "/usr/bin/${pkgname}" "${pkgdir}/usr/bin/${pkgname}${_major_ver}" + ln -s "/usr/lib/${pkgname}" "${pkgdir}/usr/lib/${pkgname}${_major_ver}" + fi + + # Install .desktop and icon file (see default_app-icon.patch) + install -Dm644 electron.desktop \ + "${pkgdir}/usr/share/applications/${pkgname}.desktop" + install -Dm644 src/electron/default_app/icon.png \ + "${pkgdir}/usr/share/pixmaps/${pkgname}.png" # hicolor has no 1024x1024 +} Added: electron20/trunk/chromium-tflite-system-zlib.patch =================================================================== --- electron20/trunk/chromium-tflite-system-zlib.patch (rev 0) +++ electron20/trunk/chromium-tflite-system-zlib.patch 2023-01-05 20:24:04 UTC (rev 1378354) @@ -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 { Added: electron20/trunk/default_app-icon.patch =================================================================== --- electron20/trunk/default_app-icon.patch (rev 0) +++ electron20/trunk/default_app-icon.patch 2023-01-05 20:24:04 UTC (rev 1378354) @@ -0,0 +1,21 @@ +--- a/electron/default_app/default_app.ts ++++ b/electron/default_app/default_app.ts +@@ -60,7 +60,7 @@ + }; + + if (process.platform === 'linux') { +- options.icon = path.join(__dirname, 'icon.png'); ++ options.icon = '/usr/share/pixmaps/electron.png'; + } + + mainWindow = new BrowserWindow(options); +--- a/electron/filenames.gni ++++ b/electron/filenames.gni +@@ -6,7 +6,6 @@ + ] + + default_app_static_sources = [ +- "default_app/icon.png", + "default_app/index.html", + "default_app/package.json", + "default_app/styles.css", Added: electron20/trunk/electron-launcher.sh =================================================================== --- electron20/trunk/electron-launcher.sh (rev 0) +++ electron20/trunk/electron-launcher.sh 2023-01-05 20:24:04 UTC (rev 1378354) @@ -0,0 +1,20 @@ +#!/usr/bin/bash + +set -euo pipefail + +name=@ELECTRON@ +flags_file="${XDG_CONFIG_HOME:-$HOME/.config}/${name}-flags.conf" + +declare -a flags + +if [[ -f "${flags_file}" ]]; then + mapfile -t < "${flags_file}" +fi + +for line in "${MAPFILE[@]}"; do + if [[ ! "${line}" =~ ^[[:space:]]*#.* ]]; then + flags+=("${line}") + fi +done + +exec /usr/lib/${name}/electron "${flags[@]}" "$@" Added: electron20/trunk/electron.desktop =================================================================== --- electron20/trunk/electron.desktop (rev 0) +++ electron20/trunk/electron.desktop 2023-01-05 20:24:04 UTC (rev 1378354) @@ -0,0 +1,7 @@ +[Desktop Entry] +Type=Application +Name=@ELECTRON_NAME@ +Icon=@ELECTRON@ +Exec=@ELECTRON@ %u +Categories=Development;GTK; +StartupNotify=true Added: electron20/trunk/jinja-python-3.10.patch =================================================================== --- electron20/trunk/jinja-python-3.10.patch (rev 0) +++ electron20/trunk/jinja-python-3.10.patch 2023-01-05 20:24:04 UTC (rev 1378354) @@ -0,0 +1,22 @@ +--- a/runtime.py ++++ b/runtime.py +@@ -315,7 +315,7 @@ class Context(with_metaclass(ContextMeta + + # register the context as mapping if possible + try: +- from collections import Mapping ++ from collections.abc import Mapping + Mapping.register(Context) + except ImportError: + pass +--- a/sandbox.py ++++ b/sandbox.py +@@ -14,7 +14,7 @@ + """ + import types + import operator +-from collections import Mapping ++from collections.abc import Mapping + from jinja2.environment import Environment + from jinja2.exceptions import SecurityError + from jinja2._compat import string_types, PY2 Added: electron20/trunk/remove-no-opaque-pointers-flag.patch =================================================================== --- electron20/trunk/remove-no-opaque-pointers-flag.patch (rev 0) +++ electron20/trunk/remove-no-opaque-pointers-flag.patch 2023-01-05 20:24:04 UTC (rev 1378354) @@ -0,0 +1,18 @@ +--- 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/1322823): Remove flags once potential miscompile is investigated. +- cflags += [ +- "-Xclang", +- "-no-opaque-pointers", +- ] +- } +- + if (is_fuchsia) { + # TODO(https://bugs.chromium.org/p/fuchsia/issues/detail?id=77383) + cflags += [ "-Wno-deprecated-copy" ] Added: electron20/trunk/roll-src-third_party-ffmpeg.patch =================================================================== --- electron20/trunk/roll-src-third_party-ffmpeg.patch (rev 0) +++ electron20/trunk/roll-src-third_party-ffmpeg.patch 2023-01-05 20:24:04 UTC (rev 1378354) @@ -0,0 +1,333 @@ +From 6e554a30893150793c2638e3689cf208ffc8e375 Mon Sep 17 00:00:00 2001 +From: Dale Curtis <[email protected]> +Date: Sat, 2 Apr 2022 05:13:53 +0000 +Subject: [PATCH] Roll src/third_party/ffmpeg/ 574c39cce..32b2d1d526 (1125 + commits) + +https://chromium.googlesource.com/chromium/third_party/ffmpeg.git/+log/574c39cce323..32b2d1d526 + +Created with: + roll-dep src/third_party/ffmpeg + +Fixed: 1293918 +Cq-Include-Trybots: luci.chromium.try:mac_chromium_asan_rel_ng,linux_chromium_asan_rel_ng,linux_chromium_chromeos_asan_rel_ng +Change-Id: I41945d0f963e3d1f65940067bac22f63b68e37d2 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3565647 +Auto-Submit: Dale Curtis <[email protected]> +Reviewed-by: Dan Sanders <[email protected]> +Commit-Queue: Dale Curtis <[email protected]> +Cr-Commit-Position: refs/heads/main@{#988253} +--- + .../clear_key_cdm/ffmpeg_cdm_audio_decoder.cc | 29 ++++++++++--------- + media/ffmpeg/ffmpeg_common.cc | 11 +++---- + media/filters/audio_file_reader.cc | 9 +++--- + media/filters/audio_file_reader_unittest.cc | 6 ++-- + .../filters/audio_video_metadata_extractor.cc | 11 +++++-- + .../filters/ffmpeg_aac_bitstream_converter.cc | 7 +++-- + ...ffmpeg_aac_bitstream_converter_unittest.cc | 2 +- + media/filters/ffmpeg_audio_decoder.cc | 13 +++++---- + 8 files changed, 51 insertions(+), 37 deletions(-) + +diff --git a/media/cdm/library_cdm/clear_key_cdm/ffmpeg_cdm_audio_decoder.cc b/media/cdm/library_cdm/clear_key_cdm/ffmpeg_cdm_audio_decoder.cc +index e4fc3f460e2..9b1ad9f7675 100644 +--- a/media/cdm/library_cdm/clear_key_cdm/ffmpeg_cdm_audio_decoder.cc ++++ b/media/cdm/library_cdm/clear_key_cdm/ffmpeg_cdm_audio_decoder.cc +@@ -74,7 +74,7 @@ void CdmAudioDecoderConfigToAVCodecContext( + codec_context->sample_fmt = AV_SAMPLE_FMT_NONE; + } + +- codec_context->channels = config.channel_count; ++ codec_context->ch_layout.nb_channels = config.channel_count; + codec_context->sample_rate = config.samples_per_second; + + if (config.extra_data) { +@@ -124,8 +124,8 @@ void CopySamples(cdm::AudioFormat cdm_format, + case cdm::kAudioFormatPlanarS16: + case cdm::kAudioFormatPlanarF32: { + const int decoded_size_per_channel = +- decoded_audio_size / av_frame.channels; +- for (int i = 0; i < av_frame.channels; ++i) { ++ decoded_audio_size / av_frame.ch_layout.nb_channels; ++ for (int i = 0; i < av_frame.ch_layout.nb_channels; ++i) { + memcpy(output_buffer, av_frame.extended_data[i], + decoded_size_per_channel); + output_buffer += decoded_size_per_channel; +@@ -185,13 +185,14 @@ bool FFmpegCdmAudioDecoder::Initialize( + // Success! + decoding_loop_ = std::make_unique<FFmpegDecodingLoop>(codec_context_.get()); + samples_per_second_ = config.samples_per_second; +- bytes_per_frame_ = codec_context_->channels * config.bits_per_channel / 8; ++ bytes_per_frame_ = ++ codec_context_->ch_layout.nb_channels * config.bits_per_channel / 8; + output_timestamp_helper_ = + std::make_unique<AudioTimestampHelper>(config.samples_per_second); + is_initialized_ = true; + + // Store initial values to guard against midstream configuration changes. +- channels_ = codec_context_->channels; ++ channels_ = codec_context_->ch_layout.nb_channels; + av_sample_format_ = codec_context_->sample_fmt; + + return true; +@@ -291,17 +292,19 @@ cdm::Status FFmpegCdmAudioDecoder::DecodeBuffer( + for (auto& frame : audio_frames) { + int decoded_audio_size = 0; + if (frame->sample_rate != samples_per_second_ || +- frame->channels != channels_ || frame->format != av_sample_format_) { ++ frame->ch_layout.nb_channels != channels_ || ++ frame->format != av_sample_format_) { + DLOG(ERROR) << "Unsupported midstream configuration change!" + << " Sample Rate: " << frame->sample_rate << " vs " +- << samples_per_second_ << ", Channels: " << frame->channels +- << " vs " << channels_ << ", Sample Format: " << frame->format +- << " vs " << av_sample_format_; ++ << samples_per_second_ ++ << ", Channels: " << frame->ch_layout.nb_channels << " vs " ++ << channels_ << ", Sample Format: " << frame->format << " vs " ++ << av_sample_format_; + return cdm::kDecodeError; + } + + decoded_audio_size = av_samples_get_buffer_size( +- nullptr, codec_context_->channels, frame->nb_samples, ++ nullptr, codec_context_->ch_layout.nb_channels, frame->nb_samples, + codec_context_->sample_fmt, 1); + if (!decoded_audio_size) + continue; +@@ -320,9 +323,9 @@ bool FFmpegCdmAudioDecoder::OnNewFrame( + size_t* total_size, + std::vector<std::unique_ptr<AVFrame, ScopedPtrAVFreeFrame>>* audio_frames, + AVFrame* frame) { +- *total_size += av_samples_get_buffer_size(nullptr, codec_context_->channels, +- frame->nb_samples, +- codec_context_->sample_fmt, 1); ++ *total_size += av_samples_get_buffer_size( ++ nullptr, codec_context_->ch_layout.nb_channels, frame->nb_samples, ++ codec_context_->sample_fmt, 1); + audio_frames->emplace_back(av_frame_clone(frame)); + return true; + } +diff --git a/media/ffmpeg/ffmpeg_common.cc b/media/ffmpeg/ffmpeg_common.cc +index 87ca8969626..76f03d6608e 100644 +--- a/media/ffmpeg/ffmpeg_common.cc ++++ b/media/ffmpeg/ffmpeg_common.cc +@@ -345,10 +345,11 @@ bool AVCodecContextToAudioDecoderConfig(const AVCodecContext* codec_context, + codec_context->sample_fmt, codec_context->codec_id); + + ChannelLayout channel_layout = +- codec_context->channels > 8 ++ codec_context->ch_layout.nb_channels > 8 + ? CHANNEL_LAYOUT_DISCRETE +- : ChannelLayoutToChromeChannelLayout(codec_context->channel_layout, +- codec_context->channels); ++ : ChannelLayoutToChromeChannelLayout( ++ codec_context->ch_layout.u.mask, ++ codec_context->ch_layout.nb_channels); + + int sample_rate = codec_context->sample_rate; + switch (codec) { +@@ -401,7 +402,7 @@ bool AVCodecContextToAudioDecoderConfig(const AVCodecContext* codec_context, + extra_data, encryption_scheme, seek_preroll, + codec_context->delay); + if (channel_layout == CHANNEL_LAYOUT_DISCRETE) +- config->SetChannelsForDiscrete(codec_context->channels); ++ config->SetChannelsForDiscrete(codec_context->ch_layout.nb_channels); + + #if BUILDFLAG(ENABLE_PLATFORM_AC3_EAC3_AUDIO) + // These are bitstream formats unknown to ffmpeg, so they don't have +@@ -470,7 +471,7 @@ void AudioDecoderConfigToAVCodecContext(const AudioDecoderConfig& config, + + // TODO(scherkus): should we set |channel_layout|? I'm not sure if FFmpeg uses + // said information to decode. +- codec_context->channels = config.channels(); ++ codec_context->ch_layout.nb_channels = config.channels(); + codec_context->sample_rate = config.samples_per_second(); + + if (config.extra_data().empty()) { +diff --git a/media/filters/audio_file_reader.cc b/media/filters/audio_file_reader.cc +index 5f257bdfaa6..e1be5aa9a5b 100644 +--- a/media/filters/audio_file_reader.cc ++++ b/media/filters/audio_file_reader.cc +@@ -113,14 +113,15 @@ bool AudioFileReader::OpenDecoder() { + + // Verify the channel layout is supported by Chrome. Acts as a sanity check + // against invalid files. See http://crbug.com/171962 +- if (ChannelLayoutToChromeChannelLayout(codec_context_->channel_layout, +- codec_context_->channels) == ++ if (ChannelLayoutToChromeChannelLayout( ++ codec_context_->ch_layout.u.mask, ++ codec_context_->ch_layout.nb_channels) == + CHANNEL_LAYOUT_UNSUPPORTED) { + return false; + } + + // Store initial values to guard against midstream configuration changes. +- channels_ = codec_context_->channels; ++ channels_ = codec_context_->ch_layout.nb_channels; + audio_codec_ = CodecIDToAudioCodec(codec_context_->codec_id); + sample_rate_ = codec_context_->sample_rate; + av_sample_format_ = codec_context_->sample_fmt; +@@ -223,7 +224,7 @@ bool AudioFileReader::OnNewFrame( + if (frames_read < 0) + return false; + +- const int channels = frame->channels; ++ const int channels = frame->ch_layout.nb_channels; + if (frame->sample_rate != sample_rate_ || channels != channels_ || + frame->format != av_sample_format_) { + DLOG(ERROR) << "Unsupported midstream configuration change!" +diff --git a/media/filters/audio_file_reader_unittest.cc b/media/filters/audio_file_reader_unittest.cc +index 2aba7927a31..1f45a50cace 100644 +--- a/media/filters/audio_file_reader_unittest.cc ++++ b/media/filters/audio_file_reader_unittest.cc +@@ -121,11 +121,11 @@ class AudioFileReaderTest : public testing::Test { + EXPECT_FALSE(reader_->Open()); + } + +- void RunTestFailingDecode(const char* fn) { ++ void RunTestFailingDecode(const char* fn, int expect_read = 0) { + Initialize(fn); + EXPECT_TRUE(reader_->Open()); + std::vector<std::unique_ptr<AudioBus>> decoded_audio_packets; +- EXPECT_EQ(reader_->Read(&decoded_audio_packets), 0); ++ EXPECT_EQ(reader_->Read(&decoded_audio_packets), expect_read); + } + + void RunTestPartialDecode(const char* fn) { +@@ -219,7 +219,7 @@ TEST_F(AudioFileReaderTest, AAC_ADTS) { + } + + TEST_F(AudioFileReaderTest, MidStreamConfigChangesFail) { +- RunTestFailingDecode("midstream_config_change.mp3"); ++ RunTestFailingDecode("midstream_config_change.mp3", 42624); + } + #endif + +diff --git a/media/filters/audio_video_metadata_extractor.cc b/media/filters/audio_video_metadata_extractor.cc +index 185819eb936..69ff508c221 100644 +--- a/media/filters/audio_video_metadata_extractor.cc ++++ b/media/filters/audio_video_metadata_extractor.cc +@@ -113,6 +113,15 @@ bool AudioVideoMetadataExtractor::Extract(DataSource* source, + if (!stream) + continue; + ++ void* display_matrix = ++ av_stream_get_side_data(stream, AV_PKT_DATA_DISPLAYMATRIX, nullptr); ++ if (display_matrix) { ++ rotation_ = VideoTransformation::FromFFmpegDisplayMatrix( ++ static_cast<int32_t*>(display_matrix)) ++ .rotation; ++ info.tags["rotate"] = base::NumberToString(rotation_); ++ } ++ + // Extract dictionary from streams also. Needed for containers that attach + // metadata to contained streams instead the container itself, like OGG. + ExtractDictionary(stream->metadata, &info.tags); +@@ -255,8 +264,6 @@ void AudioVideoMetadataExtractor::ExtractDictionary(AVDictionary* metadata, + if (raw_tags->find(tag->key) == raw_tags->end()) + (*raw_tags)[tag->key] = tag->value; + +- if (ExtractInt(tag, "rotate", &rotation_)) +- continue; + if (ExtractString(tag, "album", &album_)) + continue; + if (ExtractString(tag, "artist", &artist_)) +diff --git a/media/filters/ffmpeg_aac_bitstream_converter.cc b/media/filters/ffmpeg_aac_bitstream_converter.cc +index 6f231c85729..ca5e5fb927d 100644 +--- a/media/filters/ffmpeg_aac_bitstream_converter.cc ++++ b/media/filters/ffmpeg_aac_bitstream_converter.cc +@@ -195,14 +195,15 @@ bool FFmpegAACBitstreamConverter::ConvertPacket(AVPacket* packet) { + if (!header_generated_ || codec_ != stream_codec_parameters_->codec_id || + audio_profile_ != stream_codec_parameters_->profile || + sample_rate_index_ != sample_rate_index || +- channel_configuration_ != stream_codec_parameters_->channels || ++ channel_configuration_ != ++ stream_codec_parameters_->ch_layout.nb_channels || + frame_length_ != header_plus_packet_size) { + header_generated_ = + GenerateAdtsHeader(stream_codec_parameters_->codec_id, + 0, // layer + stream_codec_parameters_->profile, sample_rate_index, + 0, // private stream +- stream_codec_parameters_->channels, ++ stream_codec_parameters_->ch_layout.nb_channels, + 0, // originality + 0, // home + 0, // copyrighted_stream +@@ -214,7 +215,7 @@ bool FFmpegAACBitstreamConverter::ConvertPacket(AVPacket* packet) { + codec_ = stream_codec_parameters_->codec_id; + audio_profile_ = stream_codec_parameters_->profile; + sample_rate_index_ = sample_rate_index; +- channel_configuration_ = stream_codec_parameters_->channels; ++ channel_configuration_ = stream_codec_parameters_->ch_layout.nb_channels; + frame_length_ = header_plus_packet_size; + } + +diff --git a/media/filters/ffmpeg_aac_bitstream_converter_unittest.cc b/media/filters/ffmpeg_aac_bitstream_converter_unittest.cc +index 1fd4c5ccd7d..f59bcd8fdaf 100644 +--- a/media/filters/ffmpeg_aac_bitstream_converter_unittest.cc ++++ b/media/filters/ffmpeg_aac_bitstream_converter_unittest.cc +@@ -34,7 +34,7 @@ class FFmpegAACBitstreamConverterTest : public testing::Test { + memset(&test_parameters_, 0, sizeof(AVCodecParameters)); + test_parameters_.codec_id = AV_CODEC_ID_AAC; + test_parameters_.profile = FF_PROFILE_AAC_MAIN; +- test_parameters_.channels = 2; ++ test_parameters_.ch_layout.nb_channels = 2; + test_parameters_.extradata = extradata_header_; + test_parameters_.extradata_size = sizeof(extradata_header_); + } +diff --git a/media/filters/ffmpeg_audio_decoder.cc b/media/filters/ffmpeg_audio_decoder.cc +index 6a56c675f7d..4615fdeb3fb 100644 +--- a/media/filters/ffmpeg_audio_decoder.cc ++++ b/media/filters/ffmpeg_audio_decoder.cc +@@ -28,7 +28,7 @@ namespace media { + + // Return the number of channels from the data in |frame|. + static inline int DetermineChannels(AVFrame* frame) { +- return frame->channels; ++ return frame->ch_layout.nb_channels; + } + + // Called by FFmpeg's allocation routine to allocate a buffer. Uses +@@ -231,7 +231,7 @@ bool FFmpegAudioDecoder::OnNewFrame(const DecoderBuffer& buffer, + // Translate unsupported into discrete layouts for discrete configurations; + // ffmpeg does not have a labeled discrete configuration internally. + ChannelLayout channel_layout = ChannelLayoutToChromeChannelLayout( +- codec_context_->channel_layout, codec_context_->channels); ++ codec_context_->ch_layout.u.mask, codec_context_->ch_layout.nb_channels); + if (channel_layout == CHANNEL_LAYOUT_UNSUPPORTED && + config_.channel_layout() == CHANNEL_LAYOUT_DISCRETE) { + channel_layout = CHANNEL_LAYOUT_DISCRETE; +@@ -348,11 +348,11 @@ bool FFmpegAudioDecoder::ConfigureDecoder(const AudioDecoderConfig& config) { + // Success! + av_sample_format_ = codec_context_->sample_fmt; + +- if (codec_context_->channels != config.channels()) { ++ if (codec_context_->ch_layout.nb_channels != config.channels()) { + MEDIA_LOG(ERROR, media_log_) + << "Audio configuration specified " << config.channels() + << " channels, but FFmpeg thinks the file contains " +- << codec_context_->channels << " channels"; ++ << codec_context_->ch_layout.nb_channels << " channels"; + ReleaseFFmpegResources(); + state_ = DecoderState::kUninitialized; + return false; +@@ -403,7 +403,7 @@ int FFmpegAudioDecoder::GetAudioBuffer(struct AVCodecContext* s, + if (frame->nb_samples <= 0) + return AVERROR(EINVAL); + +- if (s->channels != channels) { ++ if (s->ch_layout.nb_channels != channels) { + DLOG(ERROR) << "AVCodecContext and AVFrame disagree on channel count."; + return AVERROR(EINVAL); + } +@@ -436,7 +436,8 @@ int FFmpegAudioDecoder::GetAudioBuffer(struct AVCodecContext* s, + ChannelLayout channel_layout = + config_.channel_layout() == CHANNEL_LAYOUT_DISCRETE + ? CHANNEL_LAYOUT_DISCRETE +- : ChannelLayoutToChromeChannelLayout(s->channel_layout, s->channels); ++ : ChannelLayoutToChromeChannelLayout(s->ch_layout.u.mask, ++ s->ch_layout.nb_channels); + + if (channel_layout == CHANNEL_LAYOUT_UNSUPPORTED) { + DLOG(ERROR) << "Unsupported channel layout."; Added: electron20/trunk/std-vector-non-const.patch =================================================================== --- electron20/trunk/std-vector-non-const.patch (rev 0) +++ electron20/trunk/std-vector-non-const.patch 2023-01-05 20:24:04 UTC (rev 1378354) @@ -0,0 +1,109 @@ +--- a/patches/chromium/feat_add_data_parameter_to_processsingleton.patch ++++ b/patches/chromium/feat_add_data_parameter_to_processsingleton.patch +@@ -32,7 +32,7 @@ index 5a64220aaf1309832dc0ad543e353de67fe0a779..e75c4f0d7cf1cac2e5862eb858800359 + - const base::FilePath& current_directory)>; + + base::RepeatingCallback<bool(const base::CommandLine& command_line, + + const base::FilePath& current_directory, +-+ const std::vector<const uint8_t> additional_data)>; +++ const std::vector<uint8_t> additional_data)>; + + #if BUILDFLAG(IS_WIN) + ProcessSingleton(const std::string& program_name, +@@ -73,7 +73,7 @@ index 7d3a441bdb64268ed5fbfa7bf589fb35a2fd1b75..a3e45e9baa09bfc87be5b7ff589ac768 + // |reader| is for sending back ACK message. + void HandleMessage(const std::string& current_dir, + const std::vector<std::string>& argv, +-+ const std::vector<const uint8_t> additional_data, +++ const std::vector<uint8_t> additional_data, + SocketReader* reader); + + private: +@@ -84,7 +84,7 @@ index 7d3a441bdb64268ed5fbfa7bf589fb35a2fd1b75..a3e45e9baa09bfc87be5b7ff589ac768 + - const std::string& current_dir, const std::vector<std::string>& argv, + + const std::string& current_dir, + + const std::vector<std::string>& argv, +-+ const std::vector<const uint8_t> additional_data, +++ const std::vector<uint8_t> additional_data, + SocketReader* reader) { + DCHECK(ui_task_runner_->BelongsToCurrentThread()); + DCHECK(reader); +@@ -114,7 +114,7 @@ index 7d3a441bdb64268ed5fbfa7bf589fb35a2fd1b75..a3e45e9baa09bfc87be5b7ff589ac768 + + base::StringToSizeT(tokens[0], &num_args); + + std::vector<std::string> command_line(tokens.begin() + 1, tokens.begin() + 1 + num_args); + + +-+ std::vector<const uint8_t> additional_data; +++ std::vector<uint8_t> additional_data; + + if (tokens.size() >= 3 + num_args) { + + size_t additional_data_size; + + base::StringToSizeT(tokens[1 + num_args], &additional_data_size); +@@ -123,7 +123,7 @@ index 7d3a441bdb64268ed5fbfa7bf589fb35a2fd1b75..a3e45e9baa09bfc87be5b7ff589ac768 + + std::string(1, kTokenDelimiter)); + + const uint8_t* additional_data_bits = + + reinterpret_cast<const uint8_t*>(remaining_args.c_str()); +-+ additional_data = std::vector<const uint8_t>( +++ additional_data = std::vector<uint8_t>( + + additional_data_bits, additional_data_bits + additional_data_size); + + } + + +@@ -189,7 +189,7 @@ index 0ea5eb3e3cf055d981ab73486115bac53287f2d7..fe68beb4b2522d27e07dbbb3341f100f + base::CommandLine* parsed_command_line, + - base::FilePath* current_directory) { + + base::FilePath* current_directory, +-+ std::vector<const uint8_t>* parsed_additional_data) { +++ std::vector<uint8_t>* parsed_additional_data) { + // We should have enough room for the shortest command (min_message_size) + // and also be a multiple of wchar_t bytes. The shortest command + - // possible is L"START\0\0" (empty current directory and command line). +@@ -230,7 +230,7 @@ index 0ea5eb3e3cf055d981ab73486115bac53287f2d7..fe68beb4b2522d27e07dbbb3341f100f + + msg.substr(fourth_null + 1, fifth_null - fourth_null); + + const uint8_t* additional_data_bytes = + + reinterpret_cast<const uint8_t*>(additional_data.c_str()); +-+ *parsed_additional_data = std::vector<const uint8_t>(additional_data_bytes, +++ *parsed_additional_data = std::vector<uint8_t>(additional_data_bytes, + + additional_data_bytes + additional_data_length); + + + return true; +@@ -241,7 +241,7 @@ index 0ea5eb3e3cf055d981ab73486115bac53287f2d7..fe68beb4b2522d27e07dbbb3341f100f + base::CommandLine parsed_command_line(base::CommandLine::NO_PROGRAM); + base::FilePath current_directory; + - if (!ParseCommandLine(cds, &parsed_command_line, ¤t_directory)) { +-+ std::vector<const uint8_t> additional_data; +++ std::vector<uint8_t> additional_data; + + if (!ParseCommandLine(cds, &parsed_command_line, ¤t_directory, &additional_data)) { + *result = TRUE; + return true; +--- a/shell/browser/api/electron_api_app.cc ++++ b/shell/browser/api/electron_api_app.cc +@@ -519,10 +519,10 @@ bool NotificationCallbackWrapper( + const base::RepeatingCallback< + void(const base::CommandLine& command_line, + const base::FilePath& current_directory, +- const std::vector<const uint8_t> additional_data)>& callback, ++ const std::vector<uint8_t> additional_data)>& callback, + const base::CommandLine& cmd, + const base::FilePath& cwd, +- const std::vector<const uint8_t> additional_data) { ++ const std::vector<uint8_t> additional_data) { + // Make sure the callback is called after app gets ready. + if (Browser::Get()->is_ready()) { + callback.Run(cmd, cwd, std::move(additional_data)); +@@ -1083,7 +1083,7 @@ std::string App::GetLocaleCountryCode() { + + void App::OnSecondInstance(const base::CommandLine& cmd, + const base::FilePath& cwd, +- const std::vector<const uint8_t> additional_data) { ++ const std::vector<uint8_t> additional_data) { + v8::Isolate* isolate = JavascriptEnvironment::GetIsolate(); + v8::Locker locker(isolate); + v8::HandleScope handle_scope(isolate); +--- a/shell/browser/api/electron_api_app.h ++++ b/shell/browser/api/electron_api_app.h +@@ -195,7 +195,7 @@ class App : public ElectronBrowserClient::Delegate, + std::string GetLocaleCountryCode(); + void OnSecondInstance(const base::CommandLine& cmd, + const base::FilePath& cwd, +- const std::vector<const uint8_t> additional_data); ++ const std::vector<uint8_t> additional_data); + bool HasSingleInstanceLock() const; + bool RequestSingleInstanceLock(gin::Arguments* args); + void ReleaseSingleInstanceLock(); Added: electron20/trunk/use-system-libraries-in-node.patch =================================================================== --- electron20/trunk/use-system-libraries-in-node.patch (rev 0) +++ electron20/trunk/use-system-libraries-in-node.patch 2023-01-05 20:24:04 UTC (rev 1378354) @@ -0,0 +1,53 @@ +--- a/third_party/electron_node/BUILD.gn ++++ b/third_party/electron_node/BUILD.gn +@@ -42,6 +42,18 @@ + node_module_version = "" + } + ++if (is_linux) { ++ import("//build/config/linux/pkg_config.gni") ++ ++ pkg_config("cares") { ++ packages = [ "libcares" ] ++ } ++ ++ pkg_config("nghttp2") { ++ packages = [ "libnghttp2" ] ++ } ++} ++ + assert(!node_use_dtrace, "node_use_dtrace not supported in GN") + assert(!node_use_etw, "node_use_etw not supported in GN") + +@@ -182,11 +194,9 @@ + component("node_lib") { + deps = [ + ":node_js2c", +- "deps/cares", + "deps/histogram", + "deps/googletest:gtest", + "deps/llhttp", +- "deps/nghttp2", + "deps/uvwasi", + "//third_party/zlib", + "//third_party/brotli:dec", +@@ -202,6 +212,19 @@ + public_configs = [ ":node_lib_config" ] + include_dirs = [ "src" ] + libs = [] ++ if (is_linux) { ++ configs += [ ++ ":cares", ++ ":nghttp2", ++ ] ++ libs += [ "http_parser" ] ++ } else { ++ deps += [ ++ "deps/cares", ++ "deps/http_parser", ++ "deps/nghttp2", ++ ] ++ } + frameworks = [] + cflags_cc = [ + "-Wno-deprecated-declarations", Added: electron20/trunk/x11-ozone-fix-X11-screensaver-suspension.patch =================================================================== --- electron20/trunk/x11-ozone-fix-X11-screensaver-suspension.patch (rev 0) +++ electron20/trunk/x11-ozone-fix-X11-screensaver-suspension.patch 2023-01-05 20:24:04 UTC (rev 1378354) @@ -0,0 +1,490 @@ +From 8c1ebea5f601b0b5247535dcdfd01755f3e6e1a6 Mon Sep 17 00:00:00 2001 +From: Andrew Wolfers <[email protected]> +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 <[email protected]> +Reviewed-by: Thomas Anderson <[email protected]> +Reviewed-by: Scott Violet <[email protected]> +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;
