www/ungoogled-chromium: add port of ungoogled chromium

ungoogled-chromium is a free and open-source Chromium-based web browser with
the aim of increasing privacy through removing Google components and blobs.

additionaly to the upstream version of ungoogled-chromium, patches have been
added to support parallel installation by using separate cache and config
directories

www/Makefile

@@ -2302,6 +2302,7 @@
     SUBDIR += uchiwa
     SUBDIR += ufdbguard
     SUBDIR += ulfius
+    SUBDIR += ungoogled-chromium
     SUBDIR += unit
     SUBDIR += unit-java
     SUBDIR += unit-perl

www/ungoogled-chromium/Makefile

@@ -0,0 +1,372 @@
+PORTNAME=	ungoogled-chromium
+PORTVERSION=	106.0.5249.91
+UGVERSION=	${DISTVERSION}-1
+CATEGORIES=	www wayland
+MASTER_SITES=	https://commondatastorage.googleapis.com/chromium-browser-official/ \
+		https://nerd.hu/distfiles/:external
+DISTFILES=	chromium-${DISTVERSION}${EXTRACT_SUFX} \
+		ungoogled-chromium-${UGVERSION}.tar.gz:external
+
+MAINTAINER=	chromium@FreeBSD.org
+COMMENT=	Google web browser based on WebKit sans integration with Google
+WWW=		https://github.com/ungoogled-software/ungoogled-chromium
+
+LICENSE=	BSD3CLAUSE LGPL21 MPL11
+LICENSE_COMB=	multi
+
+ONLY_FOR_ARCHS=	aarch64 amd64 i386
+
+PATCH_DEPENDS=	gpatch:devel/patch \
+		${PYTHON_VERSION}:lang/python${PYTHON_SUFFIX}
+
+BUILD_DEPENDS=	bash:shells/bash \
+		${PYTHON_PKGNAMEPREFIX}Jinja2>0:devel/py-Jinja2@${PY_FLAVOR} \
+		${PYTHON_PKGNAMEPREFIX}ply>0:devel/py-ply@${PY_FLAVOR} \
+		gperf:devel/gperf \
+		flock:sysutils/flock \
+		node:www/node \
+		xcb-proto>0:x11/xcb-proto \
+		${LOCALBASE}/include/linux/videodev2.h:multimedia/v4l_compat \
+		${LOCALBASE}/share/usbids/usb.ids:misc/usbids \
+		${PYTHON_PKGNAMEPREFIX}html5lib>0:www/py-html5lib@${PY_FLAVOR} \
+		${LOCALBASE}/include/va/va.h:multimedia/libva \
+		${LOCALBASE}/libdata/pkgconfig/dri.pc:graphics/mesa-dri
+
+LIB_DEPENDS=	libatk-bridge-2.0.so:accessibility/at-spi2-atk \
+		libatspi.so:accessibility/at-spi2-core \
+		libspeechd.so:accessibility/speech-dispatcher \
+		libsnappy.so:archivers/snappy \
+		libFLAC.so:audio/flac \
+		libopus.so:audio/opus \
+		libspeex.so:audio/speex \
+		libdbus-1.so:devel/dbus \
+		libdbus-glib-1.so:devel/dbus-glib \
+		libevent.so:devel/libevent \
+		libicuuc.so:devel/icu \
+		libjsoncpp.so:devel/jsoncpp \
+		libpci.so:devel/libpci \
+		libnspr4.so:devel/nspr \
+		libre2.so:devel/re2 \
+		libcairo.so:graphics/cairo \
+		libdrm.so:graphics/libdrm \
+		libexif.so:graphics/libexif \
+		libpng.so:graphics/png \
+		libwebp.so:graphics/webp \
+		libopenh264.so:multimedia/openh264 \
+		libfreetype.so:print/freetype2 \
+		libharfbuzz.so:print/harfbuzz \
+		libharfbuzz-icu.so:print/harfbuzz-icu \
+		libgcrypt.so:security/libgcrypt \
+		libsecret-1.so:security/libsecret \
+		libnss3.so:security/nss \
+		libexpat.so:textproc/expat2 \
+		libfontconfig.so:x11-fonts/fontconfig \
+		libwayland-client.so:graphics/wayland \
+		libxkbcommon.so:x11/libxkbcommon \
+		libxshmfence.so:x11/libxshmfence
+
+RUN_DEPENDS=	xdg-open:devel/xdg-utils \
+		noto-basic>0:x11-fonts/noto-basic
+
+USES=		bison compiler:c++17-lang cpe desktop-file-utils gl gnome iconv jpeg \
+		localbase:ldflags ninja perl5 pkgconfig python:3.7+,build shebangfix \
+		tar:xz xorg
+
+CPE_VENDOR=	google
+CPE_PRODUCT=	chrome
+USE_GL=		gbm gl
+USE_GNOME=	atk dconf gdkpixbuf2 glib20 gtk30 libxml2 libxslt
+USE_LDCONFIG=	${DATADIR}
+USE_PERL5=	build
+USE_XORG=	x11 xcb xcomposite xcursor xext xdamage xfixes xi \
+		xorgproto xrandr xrender xscrnsaver xtst
+SHEBANG_FILES=	chrome/tools/build/linux/chrome-wrapper buildtools/linux64/clang-format
+
+MAKE_ARGS=	-C out/${BUILDTYPE}
+ALL_TARGET=	chrome
+
+BINARY_ALIAS=	python3=${PYTHON_CMD}
+
+# TODO bz@ : install libwidevinecdm.so (see third_party/widevine/cdm/BUILD.gn)
+#
+# Run "./out/${BUILDTYPE}/gn args out/${BUILDTYPE} --list" for all variables.
+# Some parts don't have use_system_* flag, and can be turned on/off by using
+# replace_gn_files.py script, some parts just turned on/off for target host
+# OS "target_os == is_bsd", like libusb, libpci.
+GN_ARGS+=	fatal_linker_warnings=false \
+		icu_use_data_file=false \
+		is_clang=true \
+		optimize_webui=true \
+		toolkit_views=true \
+		use_allocator="none" \
+		use_allocator_shim=false \
+		use_aura=true \
+		use_custom_libcxx=false \
+		use_gnome_keyring=false \
+		use_lld=true \
+		use_sysroot=false \
+		use_system_freetype=false \
+		use_system_harfbuzz=true \
+		use_system_libjpeg=true \
+		use_system_libwayland=true \
+		use_system_wayland_scanner=true \
+		use_udev=false \
+		extra_cxxflags="${CXXFLAGS}" \
+		extra_ldflags="${LDFLAGS}"
+
+# sync with flags.gni
+GN_ARGS+=	build_with_tflite_lib=false \
+		chrome_pgo_phase=0 \
+		clang_use_chrome_plugins=false \
+		disable_fieldtrial_testing_config=true \
+		enable_hangout_services_extension=false \
+		enable_js_type_check=false \
+		enable_mdns=false \
+		enable_mse_mpeg2ts_stream_parser=true \
+		enable_nacl=false \
+		enable_reading_list=false \
+		enable_remoting=false \
+		enable_reporting=false \
+		enable_service_discovery=false \
+		exclude_unwind_tables=true \
+		google_api_key="" \
+		google_default_client_id="" \
+		google_default_client_secret="" \
+		safe_browsing_mode=0 \
+		treat_warnings_as_errors=false \
+		use_official_google_api_keys=false \
+		use_unofficial_version_number=false
+
+# TODO: investigate building with these options:
+# use_system_minigbm
+GN_BOOTSTRAP_FLAGS=	--no-clean --no-rebuild --skip-generate-buildfiles
+
+SUB_FILES=	ungoogled-chromium.desktop ungoogled-chromium
+SUB_LIST+=	COMMENT="${COMMENT}"
+
+OPTIONS_DEFINE=		CODECS CUPS DEBUG DRIVER KERBEROS LTO TEST
+OPTIONS_DEFAULT=	CODECS CUPS DRIVER KERBEROS SNDIO
+OPTIONS_EXCLUDE_aarch64=LTO
+OPTIONS_GROUP=		AUDIO
+OPTIONS_GROUP_AUDIO=	ALSA PULSEAUDIO SNDIO
+OPTIONS_RADIO=		KERBEROS
+OPTIONS_RADIO_KERBEROS=	HEIMDAL HEIMDAL_BASE MIT
+OPTIONS_SUB=		yes
+CODECS_DESC=		Compile and enable patented codecs like H.264
+DRIVER_DESC=		Install chromedriver
+HEIMDAL_BASE_DESC=	Heimdal Kerberos (base)
+HEIMDAL_DESC=		Heimdal Kerberos (security/heimdal)
+MIT_DESC=		MIT Kerberos (security/krb5)
+
+ALSA_LIB_DEPENDS=	libasound.so:audio/alsa-lib
+ALSA_RUN_DEPENDS=	${LOCALBASE}/lib/alsa-lib/libasound_module_pcm_oss.so:audio/alsa-plugins \
+			alsa-lib>=1.1.1_1:audio/alsa-lib
+ALSA_VARS=		GN_ARGS+=use_alsa=true
+ALSA_VARS_OFF=		GN_ARGS+=use_alsa=false
+
+CODECS_VARS=		GN_ARGS+=ffmpeg_branding="Chrome" \
+			GN_ARGS+=proprietary_codecs=true
+CODECS_VARS_OFF=	GN_ARGS+=ffmpeg_branding="Chromium" \
+			GN_ARGS+=proprietary_codecs=false
+
+CUPS_LIB_DEPENDS=	libcups.so:print/cups
+CUPS_VARS=		GN_ARGS+=use_cups=true
+CUPS_VARS_OFF=		GN_ARGS+=use_cups=false
+
+DEBUG_BUILD_DEPENDS=	esbuild:devel/esbuild
+DEBUG_VARS=		BUILDTYPE=Debug \
+			GN_ARGS+=is_debug=true \
+			GN_ARGS+=is_component_build=false \
+			GN_ARGS+=symbol_level=1 \
+			GN_BOOTSTRAP_FLAGS+=--debug \
+			WANTSPACE="21 GB"
+DEBUG_VARS_OFF=		BUILDTYPE=Release \
+			GN_ARGS+=blink_symbol_level=0 \
+			GN_ARGS+=is_debug=false \
+			GN_ARGS+=is_official_build=true \
+			GN_ARGS+=symbol_level=0 \
+			WANTSPACE="14 GB"
+
+DRIVER_MAKE_ARGS=	chromedriver
+
+HEIMDAL_LIB_DEPENDS=	libkrb.so.26:security/heimdal
+KERBEROS_VARS=		GN_ARGS+=use_kerberos=true
+KERBEROS_VARS_OFF=	GN_ARGS+=use_kerberos=false
+
+LTO_VARS=		GN_ARGS+=use_thin_lto=true \
+			GN_ARGS+=thin_lto_enable_optimizations=true \
+			WANTSPACE="14 GB"
+LTO_VARS_OFF=		GN_ARGS+=use_thin_lto=false
+
+MIT_LIB_DEPENDS=	libkrb.so.3:security/krb5
+PULSEAUDIO_LIB_DEPENDS=	libpulse.so:audio/pulseaudio
+PULSEAUDIO_VARS=	GN_ARGS+=use_pulseaudio=true
+PULSEAUDIO_VARS_OFF=	GN_ARGS+=use_pulseaudio=false
+
+# With SNDIO=on we exclude audio_manager_linux from the build (see
+# media/audio/BUILD.gn) and use audio_manager_openbsd which does not
+# support falling back to ALSA or PulseAudio.
+SNDIO_PREVENTS=		ALSA PULSEAUDIO
+SNDIO_LIB_DEPENDS=	libsndio.so:audio/sndio
+SNDIO_VARS=		GN_ARGS+=use_sndio=true
+SNDIO_VARS_OFF=		GN_ARGS+=use_sndio=false
+
+.include "Makefile.tests"
+TEST_DISTFILES=		chromium-${DISTVERSION}-testdata${EXTRACT_SUFX} \
+			test_fonts-336e775eec536b2d785cc80eff6ac39051931286.tar.gz:external
+TEST_ALL_TARGET=	${TEST_TARGETS}
+
+.include <bsd.port.options.mk>
+.include <bsd.port.pre.mk>
+
+.if ${PORT_OPTIONS:MHEIMDAL_BASE} && !exists(/usr/lib/libkrb5.so)
+IGNORE=		you have selected HEIMDAL_BASE but do not have Heimdal installed in base
+.endif
+
+.if ${COMPILER_VERSION} != 130
+LLVM_DEFAULT=		13
+BUILD_DEPENDS+=		clang${LLVM_DEFAULT}:devel/llvm${LLVM_DEFAULT}
+BINARY_ALIAS+=		cpp=${LOCALBASE}/bin/clang-cpp${LLVM_DEFAULT} \
+			cc=${LOCALBASE}/bin/clang${LLVM_DEFAULT} \
+			c++=${LOCALBASE}/bin/clang++${LLVM_DEFAULT} \
+			ar=${LOCALBASE}/bin/llvm-ar${LLVM_DEFAULT} \
+			nm=${LOCALBASE}/bin/llvm-nm${LLVM_DEFAULT} \
+			ld=${LOCALBASE}/bin/ld.lld${LLVM_DEFAULT}
+.else
+BINARY_ALIAS+=		ar=/usr/bin/llvm-ar \
+			nm=/usr/bin/llvm-nm
+.endif
+
+# swiftshader/lib/{libEGL.so,libGLESv2.so} is x86 only
+.if ${ARCH} == aarch64
+PLIST_SUB+=	NOT_AARCH64="@comment "
+.else
+PLIST_SUB+=	NOT_AARCH64=""
+.endif
+
+# Allow relocations against read-only segments (override lld default)
+LDFLAGS_i386=	-Wl,-znotext
+
+# TODO: -isystem, would be just as ugly as this approach, but more reliably
+# build would fail without C_INCLUDE_PATH/CPLUS_INCLUDE_PATH env var set.
+MAKE_ENV+=	C_INCLUDE_PATH=${LOCALBASE}/include \
+		CPLUS_INCLUDE_PATH=${LOCALBASE}/include
+
+WRKSRC=		${WRKDIR}/chromium-${DISTVERSION}
+
+pre-everything::
+	@${ECHO_MSG}
+	@${ECHO_MSG} "To build Ungoogled Chromium, you should have around 2GB of memory"
+	@${ECHO_MSG} "and around ${WANTSPACE} of free disk space."
+	@${ECHO_MSG}
+
+post-extract-TEST-on:
+	@${MKDIR} ${WRKSRC}/third_party/test_fonts/test_fonts
+	@${MV} ${WRKDIR}/test_fonts ${WRKSRC}/third_party/test_fonts/
+
+pre-patch:
+	cd ${WRKDIR}/ungoogled-chromium-${UGVERSION} && ${PYTHON_CMD} \
+		utils/prune_binaries.py ${WRKSRC} pruning.list
+	cd ${WRKDIR}/ungoogled-chromium-${UGVERSION} && PATCH_BIN=gpatch \
+		${PYTHON_CMD} utils/patches.py apply ${WRKSRC} patches
+	cd ${WRKDIR}/ungoogled-chromium-${UGVERSION} && ${PYTHON_CMD} \
+		utils/domain_substitution.py apply -r domain_regex.list -f \
+		domain_substitution.list -c ${WRKSRC}/domsubcache.tar.gz ${WRKSRC}
+
+pre-configure:
+	# We used to remove bundled libraries to be sure that chromium uses
+	# system libraries and not shipped ones.
+	# cd ${WRKSRC} && ${PYTHON_CMD} \
+	#./build/linux/unbundle/remove_bundled_libraries.py [list of preserved]
+	cd ${WRKSRC} && ${SETENV} ${CONFIGURE_ENV} ${PYTHON_CMD} \
+		./build/linux/unbundle/replace_gn_files.py --system-libraries \
+		flac fontconfig freetype harfbuzz-ng icu libdrm libevent libpng \
+		libusb libwebp libxml libxslt openh264 opus snappy || ${FALSE}
+	# Chromium uses an unreleased version of FFmpeg, so configure it
+.for brand in Chrome Chromium
+	${CP} -R \
+		${WRKSRC}/third_party/ffmpeg/chromium/config/${brand}/linux/ \
+		${WRKSRC}/third_party/ffmpeg/chromium/config/${brand}/freebsd
+.endfor
+
+do-configure:
+	# GN generator bootstrapping and generating ninja files
+	cd ${WRKSRC} && ${SETENV} ${CONFIGURE_ENV} CC=${CC} CXX=${CXX} LD=${CXX} \
+		READELF=${READELF} AR=${AR} NM=${NM} ${PYTHON_CMD} \
+		./tools/gn/bootstrap/bootstrap.py ${GN_BOOTSTRAP_FLAGS}
+	cd ${WRKSRC} && ${SETENV} ${CONFIGURE_ENV} ./out/${BUILDTYPE}/gn \
+		gen --args='${GN_ARGS}' out/${BUILDTYPE}
+
+	# Setup nodejs dependency
+	@${MKDIR} ${WRKSRC}/third_party/node/freebsd/node-freebsd/bin
+	${LN} -sf ${LOCALBASE}/bin/node ${WRKSRC}/third_party/node/freebsd/node-freebsd/bin/node
+
+	# Setup buildtools/freebsd
+	@${MKDIR} ${WRKSRC}/buildtools/freebsd
+	${LN} -sf ${WRKSRC}/buildtools/linux64/clang-format ${WRKSRC}/buildtools/freebsd
+	${LN} -sf ${WRKSRC}/out/${BUILDTYPE}/gn ${WRKSRC}/buildtools/freebsd
+	${LN} -sf /usr/bin/strip ${WRKSRC}/buildtools/freebsd/strip
+
+do-install:
+	@${MKDIR} ${STAGEDIR}${DATADIR}
+	${INSTALL_MAN} ${WRKSRC}/chrome/app/resources/manpage.1.in \
+		${STAGEDIR}${MANPREFIX}/man/man1/ungoogled-chromium.1
+	@${SED} -i "" -e 's,\@\@PACKAGE\@\@,chromium,g;s,\@\@MENUNAME\@\@,Chromium Web Browser,g' \
+		${STAGEDIR}${MANPREFIX}/man/man1/ungoogled-chromium.1
+	${CP} ${WRKSRC}/chrome/app/theme/chromium/product_logo_22_mono.png ${WRKSRC}/chrome/app/theme/chromium/product_logo_22.png
+.for s in 22 24 48 64 128 256
+	@${MKDIR} ${STAGEDIR}${PREFIX}/share/icons/hicolor/${s}x${s}/apps
+	${INSTALL_DATA} ${WRKSRC}/chrome/app/theme/chromium/product_logo_${s}.png \
+		${STAGEDIR}${PREFIX}/share/icons/hicolor/${s}x${s}/apps/ungoogled-chromium.png
+.endfor
+	${INSTALL_DATA} ${WRKSRC}/out/${BUILDTYPE}/*.png ${STAGEDIR}${DATADIR}
+	${INSTALL_DATA} ${WRKSRC}/out/${BUILDTYPE}/*.pak ${STAGEDIR}${DATADIR}
+.for d in protoc mksnapshot
+	${INSTALL_PROGRAM} ${WRKSRC}/out/${BUILDTYPE}/${d} ${STAGEDIR}${DATADIR}
+.endfor
+.for d in snapshot_blob.bin v8_context_snapshot.bin
+	${INSTALL_DATA} ${WRKSRC}/out/${BUILDTYPE}/${d} ${STAGEDIR}${DATADIR}
+.endfor
+	${INSTALL_PROGRAM} ${WRKSRC}/out/${BUILDTYPE}/chrome \
+		${STAGEDIR}${DATADIR}/ungoogled-chromium
+	cd ${WRKSRC}/out/${BUILDTYPE} && \
+		${COPYTREE_SHARE} "locales resources" ${STAGEDIR}${DATADIR}
+	@${MKDIR} ${STAGEDIR}${DESKTOPDIR}
+	${INSTALL_DATA} ${WRKDIR}/ungoogled-chromium.desktop \
+		${STAGEDIR}${DESKTOPDIR}
+	${INSTALL_SCRIPT} ${WRKDIR}/ungoogled-chromium ${STAGEDIR}${PREFIX}/bin
+	${INSTALL_SCRIPT} ${WRKSRC}/chrome/tools/build/linux/chrome-wrapper \
+		${STAGEDIR}${DATADIR}
+
+	# ANGLE, EGL, Vk
+.for f in libEGL.so libGLESv2.so libVkICD_mock_icd.so
+	${INSTALL_LIB} ${WRKSRC}/out/${BUILDTYPE}/${f} ${STAGEDIR}${DATADIR}
+.endfor
+	${INSTALL_LIB} ${WRKSRC}/out/${BUILDTYPE}/libvulkan.so.1 \
+		${STAGEDIR}${DATADIR}/libvulkan.so
+.if ${BUILDTYPE} == Debug
+	${INSTALL_LIB} ${WRKSRC}/out/${BUILDTYPE}/libVkLayer_khronos_validation.so ${STAGEDIR}${DATADIR}
+.endif
+
+	# SwiftShader
+.if ${ARCH} != aarch64
+	${INSTALL_LIB} ${WRKSRC}/out/${BUILDTYPE}/libvk_swiftshader.so ${STAGEDIR}${DATADIR}
+.endif
+
+post-install-DEBUG-on:
+	${INSTALL_LIB} ${WRKSRC}/out/${BUILDTYPE}/*.so \
+		${STAGEDIR}${DATADIR}
+	${INSTALL_PROGRAM} ${WRKSRC}/out/${BUILDTYPE}/character_data_generator \
+		${STAGEDIR}${DATADIR}
+
+post-install-DRIVER-on:
+	${INSTALL_PROGRAM} ${WRKSRC}/out/${BUILDTYPE}/chromedriver \
+		${STAGEDIR}${PREFIX}/bin/ungoogled-chromedriver
+
+do-test-TEST-on:
+.for t in ${TEST_TARGETS}
+	cd ${WRKSRC}/out/${BUILDTYPE} && ${SETENV} LC_ALL=en_US.UTF-8 \
+		./${t} --gtest_filter=-${EXCLUDE_${t}:ts:} || ${TRUE}
+.endfor
+
+.include <bsd.port.post.mk>

www/ungoogled-chromium/Makefile.tests

@@ -0,0 +1,16 @@
+TEST_TARGETS=	base_unittests \
+		blink_unittests \
+		chromedriver_unittests \
+		components_unittests \
+		content_unittests \
+		crypto_unittests \
+		gl_tests \
+		gpu_unittests \
+		headless_unittests \
+		media_unittests \
+		mojo_unittests \
+		net_unittests \
+		printing_unittests \
+		skia_unittests \
+		url_unittests \
+		wm_unittests

www/ungoogled-chromium/distinfo

@@ -0,0 +1,9 @@
+TIMESTAMP = 1664607238
+SHA256 (chromium-106.0.5249.91.tar.xz) = 5740496b406db5357e2dad131e1ed2cd1c5831732df7aea5f21036ece8e7549a
+SIZE (chromium-106.0.5249.91.tar.xz) = 1611228868
+SHA256 (ungoogled-chromium-106.0.5249.91-1.tar.gz) = 2f49d563a079fd50b68c898889c327f3b9f413ecad5b6c5030f96b932e6d0b30
+SIZE (ungoogled-chromium-106.0.5249.91-1.tar.gz) = 664907
+SHA256 (chromium-106.0.5249.91-testdata.tar.xz) = 3a72db5fadd4a370decac2c90d04b18c26054fd00aa099e1b0abad8c2ce95de7
+SIZE (chromium-106.0.5249.91-testdata.tar.xz) = 265399980
+SHA256 (test_fonts-336e775eec536b2d785cc80eff6ac39051931286.tar.gz) = a2ca2962daf482a8f943163541e1c73ba4b2694fabcd2510981f2db4eda493c8
+SIZE (test_fonts-336e775eec536b2d785cc80eff6ac39051931286.tar.gz) = 32624734

www/ungoogled-chromium/files/patch-BUILD.gn

@@ -0,0 +1,80 @@
+--- BUILD.gn.orig	2022-10-01 07:40:07 UTC
++++ BUILD.gn
+@@ -53,7 +53,7 @@ declare_args() {
+   root_extra_deps = []
+ }
+ 
+-if (is_official_build) {
++if (is_official_build && !is_bsd) {
+   # An official (maximally optimized!) component (optimized for build times)
+   # build doesn't make sense and usually doesn't work.
+   assert(!is_component_build)
+@@ -83,7 +83,6 @@ group("gn_all") {
+     "//codelabs",
+     "//components:components_unittests",
+     "//components/gwp_asan:gwp_asan_unittests",
+-    "//infra/orchestrator:orchestrator_all",
+     "//net:net_unittests",
+     "//sandbox:sandbox_unittests",
+     "//services:services_unittests",
+@@ -441,7 +440,7 @@ group("gn_all") {
+     ]
+   }
+ 
+-  if (is_linux || is_chromeos || is_android) {
++  if ((is_linux && !is_bsd) || is_chromeos || is_android) {
+     deps += [
+       "//third_party/breakpad:breakpad_unittests",
+       "//third_party/breakpad:core-2-minidump",
+@@ -634,6 +633,15 @@ group("gn_all") {
+     deps += [ "//gpu/tools/compositor_model_bench" ]
+   }
+ 
++  if (is_bsd) {
++    deps -= [
++      "//third_party/breakpad:dump_syms($host_toolchain)",
++      "//third_party/breakpad:microdump_stackwalk($host_toolchain)",
++      "//third_party/breakpad:minidump_dump($host_toolchain)",
++      "//third_party/breakpad:minidump_stackwalk($host_toolchain)",
++    ]
++  }
++
+   if (is_mac) {
+     deps += [
+       "//third_party/breakpad:crash_inspector",
+@@ -682,7 +690,7 @@ group("gn_all") {
+         host_os == "win") {
+       deps += [ "//chrome/test/mini_installer:mini_installer_tests" ]
+     }
+-  } else if (!is_android && !is_ios && !is_fuchsia) {
++  } else if (!is_android && !is_ios && !is_fuchsia && !is_bsd) {
+     deps += [ "//third_party/breakpad:symupload($host_toolchain)" ]
+   }
+ 
+@@ -1194,7 +1202,7 @@ if (!is_ios) {
+       data_deps += [ "//content/web_test:web_test_common_mojom_js_data_deps" ]
+     }
+ 
+-    if (!is_win && !is_android) {
++    if (!is_win && !is_android && !is_bsd) {
+       data_deps +=
+           [ "//third_party/breakpad:minidump_stackwalk($host_toolchain)" ]
+     }
+@@ -1203,7 +1211,7 @@ if (!is_ios) {
+       data_deps += [ "//third_party/breakpad:dump_syms($host_toolchain)" ]
+     }
+ 
+-    if (is_linux || is_chromeos) {
++    if ((is_linux && !is_bsd) || is_chromeos) {
+       data_deps += [ "//third_party/breakpad:dump_syms($host_toolchain)" ]
+     }
+ 
+@@ -1646,7 +1654,7 @@ group("chromium_builder_perf") {
+       data_deps += [ "//chrome/test:performance_browser_tests" ]
+     }
+ 
+-    if (!is_win) {
++    if (!is_win && !is_bsd) {
+       data_deps +=
+           [ "//third_party/breakpad:minidump_stackwalk($host_toolchain)" ]
+     }

www/ungoogled-chromium/files/patch-apps_ui_views_app__window__frame__view.cc

@@ -0,0 +1,11 @@
+--- apps/ui/views/app_window_frame_view.cc.orig	2022-10-01 07:40:07 UTC
++++ apps/ui/views/app_window_frame_view.cc
+@@ -137,7 +137,7 @@ gfx::Rect AppWindowFrameView::GetWindowBoundsForClient
+   gfx::Rect window_bounds = client_bounds;
+ // TODO(crbug.com/1052397): Revisit once build flag switch of lacros-chrome is
+ // complete.
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_BSD)
+   // Get the difference between the widget's client area bounds and window
+   // bounds, and grow |window_bounds| by that amount.
+   gfx::Insets native_frame_insets =

www/ungoogled-chromium/files/patch-ash_display_mirror__window__controller.cc

@@ -0,0 +1,14 @@
+--- ash/display/mirror_window_controller.cc.orig	2022-10-01 07:40:07 UTC
++++ ash/display/mirror_window_controller.cc
+@@ -296,7 +296,11 @@ void MirrorWindowController::UpdateWindow(
+                          return info.id() == iter->first;
+                        }) == display_info_list.end()) {
+         CloseAndDeleteHost(iter->second, true);
++#if defined(__llvm__)
++        mirroring_host_info_map_.erase(iter++);
++#else
+         iter = mirroring_host_info_map_.erase(iter);
++#endif
+       } else {
+         ++iter;
+       }

www/ungoogled-chromium/files/patch-base_BUILD.gn

@@ -0,0 +1,164 @@
+--- base/BUILD.gn.orig	2022-10-01 07:40:07 UTC
++++ base/BUILD.gn
+@@ -162,7 +162,7 @@ buildflag_header("ios_cronet_buildflags") {
+   flags = [ "CRONET_BUILD=$is_cronet_build" ]
+ }
+ 
+-enable_message_pump_epoll = is_linux || is_chromeos || is_android
++enable_message_pump_epoll = (is_linux || is_chromeos || is_android) && !is_bsd
+ buildflag_header("message_pump_buildflags") {
+   header = "message_pump_buildflags.h"
+   header_dir = "base/message_loop"
+@@ -1031,7 +1031,7 @@ mixed_component("base") {
+       "timer/hi_res_timer_manager_posix.cc",
+     ]
+ 
+-    if (!is_nacl && !is_apple) {
++    if (!is_nacl && !is_apple && !is_bsd) {
+       sources += [
+         "profiler/stack_copier_signal.cc",
+         "profiler/stack_copier_signal.h",
+@@ -1040,6 +1040,12 @@ mixed_component("base") {
+         "profiler/thread_delegate_posix.h",
+       ]
+     }
++
++    if (is_bsd) {
++      sources += [
++        "profiler/stack_sampler_posix.cc",
++      ]
++    }
+   }
+ 
+   if (is_win) {
+@@ -1541,11 +1547,23 @@ mixed_component("base") {
+   # Needed for <atomic> if using newer C++ library than sysroot, except if
+   # building inside the cros_sdk environment - use host_toolchain as a
+   # more robust check for this.
+-  if (!use_sysroot && (is_android || is_chromeos || (is_linux && !is_castos)) &&
++  if (!use_sysroot && (is_android || is_chromeos || (is_linux && !is_castos && !is_bsd)) &&
+       host_toolchain != "//build/toolchain/cros:host") {
+     libs += [ "atomic" ]
+   }
+ 
++  # *BSD needs libkvm
++  if (is_bsd) {
++    libs += [ "kvm" ]
++  }
++
++  if (is_freebsd) {
++    libs += [
++      "execinfo",
++      "util",
++    ]
++  }
++
+   if (use_allocator_shim) {
+     sources += [
+       "allocator/allocator_shim.cc",
+@@ -1573,7 +1591,7 @@ mixed_component("base") {
+       ]
+       configs += [ "//base/allocator:mac_no_default_new_delete_symbols" ]
+     }
+-    if (is_chromeos || is_linux) {
++    if (is_chromeos || (is_linux && !is_bsd)) {
+       sources += [
+         "allocator/allocator_shim_override_cpp_symbols.h",
+         "allocator/allocator_shim_override_glibc_weak_symbols.h",
+@@ -1629,7 +1647,7 @@ mixed_component("base") {
+ 
+   # Allow more direct string conversions on platforms with native utf8
+   # strings
+-  if (is_apple || is_chromeos || is_castos || is_cast_android || is_fuchsia) {
++  if (is_apple || is_chromeos || is_castos || is_cast_android || is_fuchsia || is_bsd) {
+     defines += [ "SYSTEM_NATIVE_UTF8" ]
+   }
+ 
+@@ -2211,6 +2229,42 @@ mixed_component("base") {
+     }
+   }
+ 
++  if (is_bsd) {
++    sources -= [
++      "files/file_path_watcher_inotify.cc",
++      "files/file_util_linux.cc",
++      "files/scoped_file_linux.cc",
++      "process/memory_linux.cc",
++      "process/process_linux.cc",
++      "system/sys_info_linux.cc",
++      "process/process_iterator_linux.cc",
++      "process/process_metrics_linux.cc",
++      "process/process_handle_linux.cc"
++    ]
++    sources += [
++      "process/memory_stubs.cc",
++      "files/file_path_watcher_kqueue.cc",
++      "files/file_path_watcher_kqueue.h",
++      "files/file_path_watcher_bsd.cc",
++    ]
++  }
++
++  if (is_openbsd) {
++    sources += [
++      "process/process_handle_openbsd.cc",
++      "process/process_iterator_openbsd.cc",
++      "process/process_metrics_openbsd.cc",
++      "system/sys_info_openbsd.cc",
++    ]
++  } else if (is_freebsd) {
++    sources += [
++      "process/process_handle_freebsd.cc",
++      "process/process_iterator_freebsd.cc",
++      "process/process_metrics_freebsd.cc",
++      "system/sys_info_freebsd.cc",
++    ]
++  }
++
+   # iOS
+   if (is_ios) {
+     sources -= [
+@@ -2310,7 +2364,7 @@ mixed_component("base") {
+   }
+ 
+   if (dep_libevent) {
+-    deps += [ "//third_party/libevent" ]
++    public_deps += [ "//third_party/libevent" ]
+   }
+ 
+   if (use_libevent) {
+@@ -3545,7 +3599,7 @@ test("base_unittests") {
+     }
+   }
+ 
+-  if (is_linux || is_chromeos) {
++  if ((is_linux || is_chromeos) && !is_bsd) {
+     sources += [
+       "debug/proc_maps_linux_unittest.cc",
+       "files/scoped_file_linux_unittest.cc",
+@@ -3593,7 +3647,7 @@ test("base_unittests") {
+       "posix/file_descriptor_shuffle_unittest.cc",
+       "posix/unix_domain_socket_unittest.cc",
+     ]
+-    if (!is_nacl && !is_apple) {
++    if (!is_nacl && !is_apple && !is_bsd) {
+       sources += [
+         "profiler/stack_copier_signal_unittest.cc",
+         "profiler/thread_delegate_posix_unittest.cc",
+@@ -3603,7 +3657,7 @@ test("base_unittests") {
+ 
+   # Allow more direct string conversions on platforms with native utf8
+   # strings
+-  if (is_apple || is_chromeos || is_castos || is_cast_android || is_fuchsia) {
++  if (is_apple || is_chromeos || is_castos || is_cast_android || is_fuchsia || is_bsd) {
+     defines += [ "SYSTEM_NATIVE_UTF8" ]
+   }
+ 
+@@ -3791,7 +3845,7 @@ test("base_unittests") {
+     }
+   }
+ 
+-  if (is_fuchsia || is_linux || is_chromeos) {
++  if ((is_fuchsia || is_linux || is_chromeos) && !is_bsd) {
+     sources += [
+       "debug/elf_reader_unittest.cc",
+       "debug/test_elf_image_builder.cc",

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_address__space__randomization.h

@@ -0,0 +1,20 @@
+--- base/allocator/partition_allocator/address_space_randomization.h.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/address_space_randomization.h
+@@ -38,7 +38,7 @@ AslrMask(uintptr_t bits) {
+ 
+ #if defined(ARCH_CPU_64_BITS)
+ 
+-  #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
++  #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR) && !defined(OS_BSD)
+ 
+     // We shouldn't allocate system pages at all for sanitizer builds. However,
+     // we do, and if random hint addresses interfere with address ranges
+@@ -128,7 +128,7 @@ AslrMask(uintptr_t bits) {
+         return AslrAddress(0x20000000ULL);
+       }
+ 
+-      #elif BUILDFLAG(IS_LINUX)
++      #elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD)
+ 
+       // Linux on arm64 can use 39, 42, 48, or 52-bit user space, depending on
+       // page size and number of levels of translation pages used. We use

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_page__allocator.h

@@ -0,0 +1,11 @@
+--- base/allocator/partition_allocator/page_allocator.h.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/page_allocator.h
+@@ -206,7 +206,7 @@ void DecommitAndZeroSystemPages(void* address, size_t 
+ // recommitted. Do not assume that this will not change over time.
+ constexpr PA_COMPONENT_EXPORT(
+     PARTITION_ALLOC) bool DecommittedMemoryIsAlwaysZeroed() {
+-#if BUILDFLAG(IS_APPLE)
++#if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_BSD)
+   return false;
+ #else
+   return true;

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_page__allocator__constants.h

@@ -0,0 +1,38 @@
+--- base/allocator/partition_allocator/page_allocator_constants.h.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/page_allocator_constants.h
+@@ -25,7 +25,7 @@
+ // elimination.
+ #define PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR __attribute__((const))
+ 
+-#elif BUILDFLAG(IS_LINUX) && defined(ARCH_CPU_ARM64)
++#elif (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD)) && defined(ARCH_CPU_ARM64)
+ // This should work for all POSIX (if needed), but currently all other
+ // supported OS/architecture combinations use either hard-coded values
+ // (such as x86) or have means to determine these values without needing
+@@ -81,7 +81,7 @@ PageAllocationGranularityShift() {
+   return 14;  // 16kB
+ #elif BUILDFLAG(IS_APPLE) && defined(ARCH_CPU_64_BITS)
+   return static_cast<size_t>(vm_page_shift);
+-#elif BUILDFLAG(IS_LINUX) && defined(ARCH_CPU_ARM64)
++#elif (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD)) && defined(ARCH_CPU_ARM64)
+   // arm64 supports 4kb (shift = 12), 16kb (shift = 14), and 64kb (shift = 16)
+   // page sizes. Retrieve from or initialize cache.
+   size_t shift = page_characteristics.shift.load(std::memory_order_relaxed);
+@@ -102,7 +102,7 @@ PageAllocationGranularity() {
+   // This is literally equivalent to |1 << PageAllocationGranularityShift()|
+   // below, but was separated out for IS_APPLE to avoid << on a non-constexpr.
+   return vm_page_size;
+-#elif BUILDFLAG(IS_LINUX) && defined(ARCH_CPU_ARM64)
++#elif (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD)) && defined(ARCH_CPU_ARM64)
+   // arm64 supports 4kb, 16kb, and 64kb page sizes. Retrieve from or
+   // initialize cache.
+   size_t size = page_characteristics.size.load(std::memory_order_relaxed);
+@@ -141,7 +141,7 @@ SystemPageShift() {
+ PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE size_t
+ SystemPageSize() {
+ #if (BUILDFLAG(IS_APPLE) && defined(ARCH_CPU_64_BITS)) || \
+-    (BUILDFLAG(IS_LINUX) && defined(ARCH_CPU_ARM64))
++    ((BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD)) && defined(ARCH_CPU_ARM64))
+   // This is literally equivalent to |1 << SystemPageShift()| below, but was
+   // separated out for 64-bit IS_APPLE and arm64 on Linux to avoid << on a
+   // non-constexpr.

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_page__allocator__internals__posix.h

@@ -0,0 +1,16 @@
+--- base/allocator/partition_allocator/page_allocator_internals_posix.h.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/page_allocator_internals_posix.h
+@@ -347,8 +347,12 @@ bool TryRecommitSystemPagesInternal(
+ 
+ void DiscardSystemPagesInternal(uintptr_t address, size_t length) {
+   void* ptr = reinterpret_cast<void*>(address);
+-#if BUILDFLAG(IS_APPLE)
++#if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_BSD)
++#if BUILDFLAG(IS_BSD)
++  int ret = madvise(ptr, length, MADV_FREE);
++#else
+   int ret = madvise(ptr, length, MADV_FREE_REUSABLE);
++#endif
+   if (ret) {
+     // MADV_FREE_REUSABLE sometimes fails, so fall back to MADV_DONTNEED.
+     ret = madvise(ptr, length, MADV_DONTNEED);

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_partition__address__space.cc

@@ -0,0 +1,11 @@
+--- base/allocator/partition_allocator/partition_address_space.cc.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/partition_address_space.cc
+@@ -238,7 +238,7 @@ void PartitionAddressSpace::UninitConfigurablePoolForT
+   setup_.configurable_pool_ = 0;
+ }
+ 
+-#if BUILDFLAG(IS_LINUX) && defined(ARCH_CPU_ARM64)
++#if (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD)) && defined(ARCH_CPU_ARM64)
+ 
+ PageCharacteristics page_characteristics;
+ 

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_partition__alloc.cc

@@ -0,0 +1,17 @@
+--- base/allocator/partition_allocator/partition_alloc.cc.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/partition_alloc.cc
+@@ -63,8 +63,14 @@ void PartitionAllocGlobalInit(OomFunction on_out_of_me
+       "maximum direct mapped allocation");
+ 
+   // Check that some of our zanier calculations worked out as expected.
++#if defined(__i386__) && defined(OS_FREEBSD)
++  // alignof(std::max_align_t) is only 4 on FreeBSD/i386
++  static_assert(internal::kSmallestBucket >= internal::kAlignment,
++                "generic smallest bucket");
++#else
+   static_assert(internal::kSmallestBucket == internal::kAlignment,
+                 "generic smallest bucket");
++#endif
+   static_assert(internal::kMaxBucketed == 917504, "generic max bucketed");
+   STATIC_ASSERT_OR_PA_CHECK(
+       internal::MaxSystemPagesPerRegularSlotSpan() <= 16,

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_partition__alloc__base_rand__util__posix.cc

@@ -0,0 +1,13 @@
+--- base/allocator/partition_allocator/partition_alloc_base/rand_util_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/partition_alloc_base/rand_util_posix.cc
+@@ -86,6 +86,10 @@ void RandBytes(void* output, size_t output_length) {
+   if (getentropy(output, output_length) == 0) {
+     return;
+   }
++#elif BUILDFLAG(IS_BSD)
++  if (getentropy(output, output_length) == 0) {
++    return;
++  }
+ #endif
+ 
+   // If the OS-specific mechanisms didn't work, fall through to reading from

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_partition__alloc__base_threading_platform__thread__internal__posix.h

@@ -0,0 +1,11 @@
+--- base/allocator/partition_allocator/partition_alloc_base/threading/platform_thread_internal_posix.h.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/partition_alloc_base/threading/platform_thread_internal_posix.h
+@@ -10,7 +10,7 @@
+ 
+ namespace partition_alloc::internal::base::internal {
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ // Current thread id is cached in thread local storage for performance reasons.
+ // In some rare cases it's important to invalidate that cache explicitly (e.g.
+ // after going through clone() syscall which does not call pthread_atfork()

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_partition__alloc__base_threading_platform__thread__posix.cc

@@ -0,0 +1,11 @@
+--- base/allocator/partition_allocator/partition_alloc_base/threading/platform_thread_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/partition_alloc_base/threading/platform_thread_posix.cc
+@@ -17,7 +17,7 @@
+ #include "base/allocator/partition_allocator/partition_alloc_base/threading/platform_thread_internal_posix.h"
+ #include "build/build_config.h"
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ #include <sys/syscall.h>
+ #include <atomic>
+ #endif

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_partition__alloc__config.h

@@ -0,0 +1,29 @@
+--- base/allocator/partition_allocator/partition_alloc_config.h.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/partition_alloc_config.h
+@@ -76,7 +76,7 @@ static_assert(sizeof(void*) != 8, "");
+ 
+ // POSIX is not only UNIX, e.g. macOS and other OSes. We do use Linux-specific
+ // features such as futex(2).
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_BSD)
+ #define PA_HAS_LINUX_KERNEL
+ #endif
+ 
+@@ -195,7 +195,7 @@ constexpr bool kUseLazyCommit = false;
+ 
+ // On these platforms, lock all the partitions before fork(), and unlock after.
+ // This may be required on more platforms in the future.
+-#if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ #define PA_HAS_ATFORK_HANDLER
+ #endif
+ 
+@@ -235,7 +235,7 @@ constexpr bool kUseLazyCommit = false;
+ //
+ // Also enabled on ARM64 macOS, as the 16kiB pages on this platform lead to
+ // larger slot spans.
+-#if BUILDFLAG(IS_LINUX) || (BUILDFLAG(IS_MAC) && defined(ARCH_CPU_ARM64))
++#if BUILDFLAG(IS_LINUX) || (BUILDFLAG(IS_MAC) && defined(ARCH_CPU_ARM64)) || BUILDFLAG(IS_BSD)
+ #define PA_PREFER_SMALLER_SLOT_SPANS
+ #endif  // BUILDFLAG(IS_LINUX) || (BUILDFLAG(IS_MAC) && defined(ARCH_CPU_ARM64))
+ 

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_partition__alloc__constants.h

@@ -0,0 +1,20 @@
+--- base/allocator/partition_allocator/partition_alloc_constants.h.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/partition_alloc_constants.h
+@@ -91,7 +91,7 @@ PartitionPageShift() {
+   return 18;  // 256 KiB
+ }
+ #elif (BUILDFLAG(IS_APPLE) && defined(ARCH_CPU_64_BITS)) || \
+-    (BUILDFLAG(IS_LINUX) && defined(ARCH_CPU_ARM64))
++    ((BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD)) && defined(ARCH_CPU_ARM64))
+ PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE size_t
+ PartitionPageShift() {
+   return PageAllocationGranularityShift() + 2;
+@@ -270,7 +270,7 @@ constexpr size_t kNumPools = 3;
+ // Special-case Android and iOS, which incur test failures with larger
+ // GigaCage. Regardless, allocating >8GiB with malloc() on these platforms is
+ // unrealistic as of 2022.
+-#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_IOS)
++#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_IOS) || BUILDFLAG(IS_BSD)
+ constexpr size_t kPoolMaxSize = 8 * kGiB;
+ #else
+ constexpr size_t kPoolMaxSize = 16 * kGiB;

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_partition__page.h

@@ -0,0 +1,29 @@
+--- base/allocator/partition_allocator/partition_page.h.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/partition_page.h
+@@ -131,13 +131,14 @@ struct SlotSpanMetadata {
+   PartitionBucket<thread_safe>* const bucket = nullptr;
+ 
+   // CHECK()ed in AllocNewSlotSpan().
+-#if defined(PA_HAS_64_BITS_POINTERS) && BUILDFLAG(IS_APPLE)
++#if (defined(PA_HAS_64_BITS_POINTERS) && BUILDFLAG(IS_APPLE)) || \
++    (BUILDFLAG(IS_FREEBSD) && defined(__i386__))
+   // System page size is not a constant on Apple OSes, but is either 4 or 16kiB
+   // (1 << 12 or 1 << 14), as checked in PartitionRoot::Init(). And
+   // PartitionPageSize() is 4 times the OS page size.
+   static constexpr size_t kMaxSlotsPerSlotSpan =
+       4 * (1 << 14) / kSmallestBucket;
+-#elif BUILDFLAG(IS_LINUX) && defined(ARCH_CPU_ARM64)
++#elif (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD)) && defined(ARCH_CPU_ARM64)
+   // System page size can be 4, 16, or 64 kiB on Linux on arm64. 64 kiB is
+   // currently (kMaxSlotsPerSlotSpanBits == 13) not supported by the code,
+   // so we use the 16 kiB maximum (64 kiB will crash).
+@@ -151,7 +152,9 @@ struct SlotSpanMetadata {
+ #endif  // defined(PA_HAS_64_BITS_POINTERS) && BUILDFLAG(IS_APPLE)
+   // The maximum number of bits needed to cover all currently supported OSes.
+   static constexpr size_t kMaxSlotsPerSlotSpanBits = 13;
++#if !BUILDFLAG(IS_FREEBSD) && defined(__i386__)
+   static_assert(kMaxSlotsPerSlotSpan < (1 << kMaxSlotsPerSlotSpanBits), "");
++#endif
+ 
+   // |marked_full| isn't equivalent to being full. Slot span is marked as full
+   // iff it isn't on the active slot span list (or any other list).

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_partition__root.cc

@@ -0,0 +1,38 @@
+--- base/allocator/partition_allocator/partition_root.cc.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/partition_root.cc
+@@ -33,7 +33,7 @@
+ #include "wow64apiset.h"
+ #endif
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ #include <pthread.h>
+ #endif
+ 
+@@ -230,7 +230,7 @@ void PartitionAllocMallocInitOnce() {
+   if (!g_global_init_called.compare_exchange_strong(expected, true))
+     return;
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+   // When fork() is called, only the current thread continues to execute in the
+   // child process. If the lock is held, but *not* by this thread when fork() is
+   // called, we have a deadlock.
+@@ -321,7 +321,7 @@ static size_t PartitionPurgeSlotSpan(
+   constexpr size_t kMaxSlotCount =
+       (PartitionPageSize() * kMaxPartitionPagesPerRegularSlotSpan) /
+       MaxPurgeableSlotSize();
+-#elif BUILDFLAG(IS_APPLE) || (BUILDFLAG(IS_LINUX) && defined(ARCH_CPU_ARM64))
++#elif BUILDFLAG(IS_APPLE) || ((BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD) && defined(ARCH_CPU_ARM64))
+   // It's better for slot_usage to be stack-allocated and fixed-size, which
+   // demands that its size be constexpr. On IS_APPLE and Linux on arm64,
+   // PartitionPageSize() is always SystemPageSize() << 2, so regardless of
+@@ -709,7 +709,7 @@ void PartitionRoot<thread_safe>::Init(PartitionOptions
+     // apple OSes.
+     PA_CHECK((internal::SystemPageSize() == (size_t{1} << 12)) ||
+              (internal::SystemPageSize() == (size_t{1} << 14)));
+-#elif BUILDFLAG(IS_LINUX) && defined(ARCH_CPU_ARM64)
++#elif (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_BSD)) && defined(ARCH_CPU_ARM64)
+     // Check runtime pagesize. Though the code is currently the same, it is
+     // not merged with the IS_APPLE case above as a 1 << 16 case needs to be
+     // added here in the future, to allow 64 kiB pagesize. That is only

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_spinning__mutex.cc

@@ -0,0 +1,47 @@
+--- base/allocator/partition_allocator/spinning_mutex.cc.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/spinning_mutex.cc
+@@ -18,7 +18,15 @@
+ 
+ #if defined(PA_HAS_LINUX_KERNEL)
+ #include <errno.h>
++#if defined(OS_OPENBSD)
++#include <sys/futex.h>
++#elif defined(OS_FREEBSD)
++#include <sys/types.h>
++#include <sys/thr.h>
++#include <sys/umtx.h>
++#else
+ #include <linux/futex.h>
++#endif
+ #include <sys/syscall.h>
+ #include <unistd.h>
+ #endif  // defined(PA_HAS_LINUX_KERNEL)
+@@ -107,8 +115,13 @@ void SpinningMutex::FutexWait() {
+   // |kLockedContended| anymore. Note that even without spurious wakeups, the
+   // value of |state_| is not guaranteed when this returns, as another thread
+   // may get the lock before we get to run.
++#if defined(OS_FREEBSD)
++  int err = _umtx_op(&state_, UMTX_OP_WAIT_UINT_PRIVATE,
++                    kLockedContended, nullptr, nullptr);
++#else
+   int err = syscall(SYS_futex, &state_, FUTEX_WAIT | FUTEX_PRIVATE_FLAG,
+                     kLockedContended, nullptr, nullptr, 0);
++#endif
+ 
+   if (err) {
+     // These are programming error, check them.
+@@ -120,8 +133,14 @@ void SpinningMutex::FutexWait() {
+ 
+ void SpinningMutex::FutexWake() {
+   int saved_errno = errno;
++#if defined(OS_FREEBSD)
++  long retval = _umtx_op(&state_, UMTX_OP_WAKE_PRIVATE,
++                         1 /* wake up a single waiter */, nullptr, nullptr);
++#else
+   long retval = syscall(SYS_futex, &state_, FUTEX_WAKE | FUTEX_PRIVATE_FLAG,
+                         1 /* wake up a single waiter */, nullptr, nullptr, 0);
++#endif
++
+   PA_CHECK(retval != -1);
+   errno = saved_errno;
+ }

www/ungoogled-chromium/files/patch-base_allocator_partition__allocator_starscan_stack_stack.cc

@@ -0,0 +1,50 @@
+--- base/allocator/partition_allocator/starscan/stack/stack.cc.orig	2022-10-01 07:40:07 UTC
++++ base/allocator/partition_allocator/starscan/stack/stack.cc
+@@ -17,6 +17,10 @@
+ #include <pthread.h>
+ #endif
+ 
++#if defined(OS_BSD)
++#include <pthread_np.h>
++#endif
++
+ #if defined(LIBC_GLIBC)
+ extern "C" void* __libc_stack_end;
+ #endif
+@@ -47,6 +51,36 @@ void* GetStackTop() {
+ 
+ void* GetStackTop() {
+   return pthread_get_stackaddr_np(pthread_self());
++}
++
++#elif defined(OS_OPENBSD)
++
++void* GetStackTop() {
++  stack_t ss;
++  if (pthread_stackseg_np(pthread_self(), &ss) != 0)
++    return nullptr;
++  return reinterpret_cast<uint8_t*>(ss.ss_sp);
++}
++
++#elif defined(OS_FREEBSD)
++
++void* GetStackTop() {
++   pthread_attr_t attr;
++   int error = pthread_attr_init(&attr);
++   if (error) {
++     return nullptr;
++   }
++   error = pthread_attr_get_np(pthread_self(), &attr);
++   if (!error) {
++     void* base;
++     size_t size;
++     error = pthread_attr_getstack(&attr, &base, &size);
++     PA_CHECK(!error);
++     pthread_attr_destroy(&attr);
++     return reinterpret_cast<uint8_t*>(base) + size;
++   }
++  pthread_attr_destroy(&attr);
++  return nullptr;
+ }
+ 
+ #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)

www/ungoogled-chromium/files/patch-base_atomicops.h

@@ -0,0 +1,14 @@
+--- base/atomicops.h.orig	2022-10-01 07:40:07 UTC
++++ base/atomicops.h
+@@ -56,7 +56,11 @@ typedef intptr_t Atomic64;
+ 
+ // Use AtomicWord for a machine-sized pointer.  It will use the Atomic32 or
+ // Atomic64 routines below, depending on your architecture.
++#if !defined(OS_OPENBSD) && defined(__i386__)
++typedef Atomic32 AtomicWord;
++#else
+ typedef intptr_t AtomicWord;
++#endif
+ 
+ // Atomically execute:
+ //      result = *ptr;

www/ungoogled-chromium/files/patch-base_base__paths__posix.cc

@@ -0,0 +1,98 @@
+--- base/base_paths_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/base_paths_posix.cc
+@@ -15,6 +15,7 @@
+ #include <ostream>
+ #include <string>
+ 
++#include "base/command_line.h"
+ #include "base/environment.h"
+ #include "base/files/file_path.h"
+ #include "base/files/file_util.h"
+@@ -25,9 +26,13 @@
+ #include "base/process/process_metrics.h"
+ #include "build/build_config.h"
+ 
+-#if BUILDFLAG(IS_FREEBSD)
++#if BUILDFLAG(IS_BSD)
+ #include <sys/param.h>
+ #include <sys/sysctl.h>
++#if BUILDFLAG(IS_OPENBSD)
++#include <kvm.h>
++#define MAXTOKENS 2
++#endif
+ #elif BUILDFLAG(IS_SOLARIS) || BUILDFLAG(IS_AIX)
+ #include <stdlib.h>
+ #endif
+@@ -68,13 +73,65 @@ bool PathProviderPosix(int key, FilePath* result) {
+       *result = FilePath(bin_dir);
+       return true;
+ #elif BUILDFLAG(IS_OPENBSD) || BUILDFLAG(IS_AIX)
+-      // There is currently no way to get the executable path on OpenBSD
+-      char* cpath;
+-      if ((cpath = getenv("CHROME_EXE_PATH")) != NULL)
+-        *result = FilePath(cpath);
+-      else
+-        *result = FilePath("/usr/local/chrome/chrome");
+-      return true;
++      char *cpath;
++#if !BUILDFLAG(IS_AIX)
++      struct kinfo_file *files;
++      kvm_t *kd = NULL;
++      char errbuf[_POSIX2_LINE_MAX];
++      static char retval[PATH_MAX];
++      int cnt;
++      struct stat sb;
++      pid_t cpid = getpid();
++      bool ret = false;
++
++      const base::CommandLine* command_line =
++          base::CommandLine::ForCurrentProcess();
++
++      VLOG(1) << "PathProviderPosix argv: " << command_line->argv()[0];
++
++      if (realpath(command_line->argv()[0].c_str(), retval) == NULL)
++        goto out;
++
++      if (stat(command_line->argv()[0].c_str(), &sb) < 0)
++        goto out;
++
++      if (!command_line->HasSwitch("no-sandbox")) {
++        ret = true;
++        *result = FilePath(retval);
++        VLOG(1) << "PathProviderPosix (sandbox) result: " << retval;
++        goto out;
++      }
++
++      if ((kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf)) == NULL)
++        goto out;
++
++      if ((files = kvm_getfiles(kd, KERN_FILE_BYPID, cpid,
++                                sizeof(struct kinfo_file), &cnt)) == NULL)
++        goto out;
++
++      for (int i = 0; i < cnt; i++) {
++        if (files[i].fd_fd == KERN_FILE_TEXT &&
++            files[i].va_fsid == static_cast<uint32_t>(sb.st_dev) &&
++            files[i].va_fileid == sb.st_ino) {
++          ret = true;
++          *result = FilePath(retval);
++          VLOG(1) << "PathProviderPosix result: " << retval;
++        }
++      }
++out:
++      if (kd)
++        kvm_close(kd);
++      if (!ret) {
++#endif
++        if ((cpath = getenv("CHROME_EXE_PATH")) != NULL)
++          *result = FilePath(cpath);
++        else
++          *result = FilePath("/usr/local/ungoogled-chromium/ungoogled-chromium");
++        return true;
++#if !BUILDFLAG(IS_AIX)
++      }
++      return ret;
++#endif
+ #endif
+     }
+     case DIR_SRC_TEST_DATA_ROOT: {

www/ungoogled-chromium/files/patch-base_base__switches.cc

@@ -0,0 +1,11 @@
+--- base/base_switches.cc.orig	2022-10-01 07:40:07 UTC
++++ base/base_switches.cc
+@@ -170,7 +170,7 @@ const char kForceFieldTrialParams[] = "force-fieldtria
+ 
+ #endif
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ // TODO(crbug.com/1176772): Remove kEnableCrashpad and IsCrashpadEnabled() when
+ // Crashpad is fully enabled on Linux. Indicates that Crashpad should be
+ // enabled.

www/ungoogled-chromium/files/patch-base_base__switches.h

@@ -0,0 +1,11 @@
+--- base/base_switches.h.orig	2022-10-01 07:40:07 UTC
++++ base/base_switches.h
+@@ -60,7 +60,7 @@ extern const char kEnableIdleTracing[];
+ extern const char kForceFieldTrialParams[];
+ #endif
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ // TODO(crbug.com/1176772): Remove kEnableCrashpad and IsCrashpadEnabled() when
+ // Crashpad is fully enabled on Linux.
+ extern const char kEnableCrashpad[];

www/ungoogled-chromium/files/patch-base_cpu.h

@@ -0,0 +1,11 @@
+--- base/cpu.h.orig	2022-10-01 07:40:07 UTC
++++ base/cpu.h
+@@ -108,7 +108,7 @@ class BASE_EXPORT CPU final {
+   const std::string& cpu_brand() const { return cpu_brand_; }
+ 
+ #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || \
+-    BUILDFLAG(IS_AIX)
++    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+   enum class CoreType {
+     kUnknown = 0,
+     kOther,

www/ungoogled-chromium/files/patch-base_debug_debugger__posix.cc

@@ -0,0 +1,68 @@
+--- base/debug/debugger_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/debug/debugger_posix.cc
+@@ -35,6 +35,10 @@
+ #include <sys/sysctl.h>
+ #endif
+ 
++#if BUILDFLAG(IS_OPENBSD)
++#include <sys/proc.h>
++#endif
++
+ #if BUILDFLAG(IS_FREEBSD)
+ #include <sys/user.h>
+ #endif
+@@ -95,32 +99,51 @@ bool BeingDebugged() {
+ 
+   // Caution: struct kinfo_proc is marked __APPLE_API_UNSTABLE.  The source and
+   // binary interfaces may change.
++#if BUILDFLAG(IS_OPENBSD)
++  struct kinfo_proc *info;
++  size_t info_size;
++#else
+   struct kinfo_proc info;
+   size_t info_size = sizeof(info);
++#endif
+ 
+ #if BUILDFLAG(IS_OPENBSD)
+   if (sysctl(mib, std::size(mib), NULL, &info_size, NULL, 0) < 0)
+     return -1;
+ 
+   mib[5] = (info_size / sizeof(struct kinfo_proc));
++  if ((info = reinterpret_cast<kinfo_proc*>(malloc(info_size))) == NULL) {
++    is_set = true;
++    being_debugged = false;
++    return being_debugged;
++  }
++
++  int sysctl_result = sysctl(mib, std::size(mib), info, &info_size, NULL, 0);
+ #endif
+ 
++#if !BUILDFLAG(IS_OPENBSD)
+   int sysctl_result = sysctl(mib, std::size(mib), &info, &info_size, NULL, 0);
++#endif
+   DCHECK_EQ(sysctl_result, 0);
+   if (sysctl_result != 0) {
+     is_set = true;
+     being_debugged = false;
+-    return being_debugged;
++    goto out;
+   }
+ 
+   // This process is being debugged if the P_TRACED flag is set.
+   is_set = true;
+ #if BUILDFLAG(IS_FREEBSD)
+   being_debugged = (info.ki_flag & P_TRACED) != 0;
+-#elif BUILDFLAG(IS_BSD)
+-  being_debugged = (info.p_flag & P_TRACED) != 0;
++#elif BUILDFLAG(IS_OPENBSD)
++  being_debugged = (info->p_psflags & PS_TRACED) != 0;
+ #else
+   being_debugged = (info.kp_proc.p_flag & P_TRACED) != 0;
++#endif
++
++out:
++#if BUILDFLAG(IS_OPENBSD)
++  free(info);
+ #endif
+   return being_debugged;
+ }

www/ungoogled-chromium/files/patch-base_debug_elf__reader.cc

@@ -0,0 +1,18 @@
+--- base/debug/elf_reader.cc.orig	2022-10-01 07:40:07 UTC
++++ base/debug/elf_reader.cc
+@@ -78,6 +78,7 @@ size_t ReadElfBuildId(const void* elf_mapped_base,
+     bool found = false;
+     while (current_section < section_end) {
+       current_note = reinterpret_cast<const Nhdr*>(current_section);
++#if !defined(OS_BSD)
+       if (current_note->n_type == NT_GNU_BUILD_ID) {
+         StringPiece note_name(current_section + sizeof(Nhdr),
+                               current_note->n_namesz);
+@@ -87,6 +88,7 @@ size_t ReadElfBuildId(const void* elf_mapped_base,
+           break;
+         }
+       }
++#endif
+ 
+       size_t section_size = bits::AlignUp(current_note->n_namesz, 4u) +
+                             bits::AlignUp(current_note->n_descsz, 4u) +

www/ungoogled-chromium/files/patch-base_debug_proc__maps__linux.cc

@@ -0,0 +1,11 @@
+--- base/debug/proc_maps_linux.cc.orig	2022-10-01 07:40:07 UTC
++++ base/debug/proc_maps_linux.cc
+@@ -13,7 +13,7 @@
+ #include "base/strings/string_split.h"
+ #include "build/build_config.h"
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_BSD)
+ #include <inttypes.h>
+ #endif
+ 

www/ungoogled-chromium/files/patch-base_debug_stack__trace__posix.cc

@@ -0,0 +1,38 @@
+--- base/debug/stack_trace_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/debug/stack_trace_posix.cc
+@@ -39,7 +39,7 @@
+ #include <AvailabilityMacros.h>
+ #endif
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ #include "base/debug/proc_maps_linux.h"
+ #endif
+ 
+@@ -698,6 +698,9 @@ class SandboxSymbolizeHelper {
+   // for the modules that are loaded in the current process.
+   // Returns true on success.
+   bool CacheMemoryRegions() {
++#if BUILDFLAG(IS_BSD)
++    return false;
++#else
+     // Reads /proc/self/maps.
+     std::string contents;
+     if (!ReadProcMaps(&contents)) {
+@@ -715,6 +718,7 @@ class SandboxSymbolizeHelper {
+ 
+     is_initialized_ = true;
+     return true;
++#endif
+   }
+ 
+   // Opens all object files and caches their file descriptors.
+@@ -871,7 +875,7 @@ size_t CollectStackTrace(void** trace, size_t count) {
+   // If we do not have unwind tables, then try tracing using frame pointers.
+   return base::debug::TraceStackFramePointers(const_cast<const void**>(trace),
+                                               count, 0);
+-#elif !defined(__UCLIBC__) && !defined(_AIX)
++#elif !defined(__UCLIBC__) && !defined(_AIX) && !BUILDFLAG(IS_BSD)
+   // Though the backtrace API man page does not list any possible negative
+   // return values, we take no chance.
+   return base::saturated_cast<size_t>(

www/ungoogled-chromium/files/patch-base_files_dir__reader__linux.h

@@ -0,0 +1,39 @@
+--- base/files/dir_reader_linux.h.orig	2022-10-01 07:40:07 UTC
++++ base/files/dir_reader_linux.h
+@@ -16,10 +16,16 @@
+ #include "base/logging.h"
+ #include "base/posix/eintr_wrapper.h"
+ 
++#include "build/build_config.h"
++
+ // See the comments in dir_reader_posix.h about this.
+ 
+ namespace base {
+ 
++#if BUILDFLAG(IS_BSD)
++#include <dirent.h>
++typedef struct dirent linux_dirent;
++#else
+ struct linux_dirent {
+   uint64_t        d_ino;
+   int64_t         d_off;
+@@ -27,6 +33,7 @@ struct linux_dirent {
+   unsigned char   d_type;
+   char            d_name[0];
+ };
++#endif
+ 
+ class DirReaderLinux {
+  public:
+@@ -61,7 +68,11 @@ class DirReaderLinux {
+     if (offset_ != size_)
+       return true;
+ 
++#if BUILDFLAG(IS_BSD)
++    const int r = getdents(fd_, reinterpret_cast<char *>(buf_), sizeof(buf_));
++#else
+     const long r = syscall(__NR_getdents64, fd_, buf_, sizeof(buf_));
++#endif
+     if (r == 0)
+       return false;
+     if (r < 0) {

www/ungoogled-chromium/files/patch-base_files_dir__reader__posix.h

@@ -0,0 +1,20 @@
+--- base/files/dir_reader_posix.h.orig	2022-10-01 07:40:07 UTC
++++ base/files/dir_reader_posix.h
+@@ -17,7 +17,7 @@
+ // seems worse than falling back to enumerating all file descriptors so we will
+ // probably never implement this on the Mac.
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_BSD)
+ #include "base/files/dir_reader_linux.h"
+ #else
+ #include "base/files/dir_reader_fallback.h"
+@@ -25,7 +25,7 @@
+ 
+ namespace base {
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_BSD)
+ typedef DirReaderLinux DirReaderPosix;
+ #else
+ typedef DirReaderFallback DirReaderPosix;

www/ungoogled-chromium/files/patch-base_files_file__path__watcher__bsd.cc

@@ -0,0 +1,57 @@
+--- base/files/file_path_watcher_bsd.cc.orig	2022-10-01 07:40:07 UTC
++++ base/files/file_path_watcher_bsd.cc
+@@ -0,0 +1,54 @@
++// Copyright 2021 The Chromium Authors. All rights reserved.
++// Use of this source code is governed by a BSD-style license that can be
++// found in the LICENSE file.
++
++#include <memory>
++
++#include "base/files/file_path_watcher.h"
++#include "base/files/file_path_watcher_kqueue.h"
++#include "base/memory/ptr_util.h"
++#include "build/build_config.h"
++
++namespace base {
++
++namespace {
++
++class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate {
++ public:
++  FilePathWatcherImpl() = default;
++  FilePathWatcherImpl(const FilePathWatcherImpl&) = delete;
++  FilePathWatcherImpl& operator=(const FilePathWatcherImpl&) = delete;
++  ~FilePathWatcherImpl() override = default;
++
++  bool Watch(const FilePath& path,
++             Type type,
++             const FilePathWatcher::Callback& callback) override {
++    DCHECK(!impl_.get());
++    if (type == Type::kRecursive) {
++      if (!FilePathWatcher::RecursiveWatchAvailable())
++        return false;
++    } else {
++      impl_ = std::make_unique<FilePathWatcherKQueue>();
++    }
++    DCHECK(impl_.get());
++    return impl_->Watch(path, type, callback);
++  }
++
++  void Cancel() override {
++    if (impl_.get())
++      impl_->Cancel();
++    set_cancelled();
++  }
++
++ private:
++  std::unique_ptr<PlatformDelegate> impl_;
++};
++
++}  // namespace
++
++FilePathWatcher::FilePathWatcher() {
++  sequence_checker_.DetachFromSequence();
++  impl_ = std::make_unique<FilePathWatcherImpl>();
++}
++
++}  // namespace base

www/ungoogled-chromium/files/patch-base_files_file__path__watcher__kqueue.h

@@ -0,0 +1,10 @@
+--- base/files/file_path_watcher_kqueue.h.orig	2022-10-01 07:40:07 UTC
++++ base/files/file_path_watcher_kqueue.h
+@@ -5,6 +5,7 @@
+ #ifndef BASE_FILES_FILE_PATH_WATCHER_KQUEUE_H_
+ #define BASE_FILES_FILE_PATH_WATCHER_KQUEUE_H_
+ 
++#include <sys/time.h>
+ #include <sys/event.h>
+ 
+ #include <memory>

www/ungoogled-chromium/files/patch-base_files_file__path__watcher__unittest.cc

@@ -0,0 +1,29 @@
+--- base/files/file_path_watcher_unittest.cc.orig	2022-10-01 07:40:07 UTC
++++ base/files/file_path_watcher_unittest.cc
+@@ -498,7 +498,7 @@ TEST_F(FilePathWatcherTest, MAYBE_WatchDirectory) {
+   VLOG(1) << "Waiting for file1 creation";
+   ASSERT_TRUE(WaitForEvents());
+ 
+-#if !BUILDFLAG(IS_APPLE)
++#if !BUILDFLAG(IS_APPLE) && !BUILDFLAG(IS_BSD)
+   // Mac implementation does not detect files modified in a directory.
+   ASSERT_TRUE(WriteFile(file1, "content v2"));
+   VLOG(1) << "Waiting for file1 modification";
+@@ -1118,7 +1118,7 @@ enum Permission {
+   Execute
+ };
+ 
+-#if BUILDFLAG(IS_APPLE)
++#if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_BSD)
+ bool ChangeFilePermissions(const FilePath& path, Permission perm, bool allow) {
+   struct stat stat_buf;
+ 
+@@ -1149,7 +1149,7 @@ bool ChangeFilePermissions(const FilePath& path, Permi
+ }
+ #endif  // BUILDFLAG(IS_APPLE)
+ 
+-#if BUILDFLAG(IS_APPLE)
++#if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_BSD)
+ // Linux implementation of FilePathWatcher doesn't catch attribute changes.
+ // http://crbug.com/78043
+ // Windows implementation of FilePathWatcher catches attribute changes that

www/ungoogled-chromium/files/patch-base_files_file__util__posix.cc

@@ -0,0 +1,52 @@
+--- base/files/file_util_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/files/file_util_posix.cc
+@@ -700,32 +700,34 @@ bool CreateDirectoryAndGetError(const FilePath& full_p
+                                 File::Error* error) {
+   ScopedBlockingCall scoped_blocking_call(
+       FROM_HERE, BlockingType::MAY_BLOCK);  // For call to mkdir().
++  const FilePath kFileSystemRoot("/");
+   std::vector<FilePath> subpaths;
+ 
+   // Collect a list of all parent directories.
+   FilePath last_path = full_path;
+-  subpaths.push_back(full_path);
++  if (full_path != kFileSystemRoot)
++    subpaths.push_back(full_path);
+   for (FilePath path = full_path.DirName();
+-       path.value() != last_path.value(); path = path.DirName()) {
++       (path.value() != last_path.value() &&
++       (path != kFileSystemRoot)); path = path.DirName()) {
+     subpaths.push_back(path);
+     last_path = path;
+   }
+ 
+   // Iterate through the parents and create the missing ones.
+   for (const FilePath& subpath : base::Reversed(subpaths)) {
+-    if (DirectoryExists(subpath))
+-      continue;
+-    if (mkdir(subpath.value().c_str(), 0700) == 0)
+-      continue;
+-    // Mkdir failed, but it might have failed with EEXIST, or some other error
+-    // due to the directory appearing out of thin air. This can occur if
+-    // two processes are trying to create the same file system tree at the same
+-    // time. Check to see if it exists and make sure it is a directory.
+-    int saved_errno = errno;
+-    if (!DirectoryExists(subpath)) {
+-      if (error)
+-        *error = File::OSErrorToFileError(saved_errno);
+-      return false;
++    if (!PathExists(subpath)) {
++      if ((mkdir(subpath.value().c_str(), 0700) == -1) &&
++          ((full_path != subpath) ? (errno != ENOENT) : (-1))) {
++        int saved_errno = errno;
++        if (error)
++          *error = File::OSErrorToFileError(saved_errno);
++        return false;
++      }
++    } else if (!DirectoryExists(subpath)) {
++        if (error)
++          *error = File::OSErrorToFileError(ENOTDIR);
++        return false;
+     }
+   }
+   return true;

www/ungoogled-chromium/files/patch-base_files_file__util__unittest.cc

@@ -0,0 +1,20 @@
+--- base/files/file_util_unittest.cc.orig	2022-10-01 07:40:07 UTC
++++ base/files/file_util_unittest.cc
+@@ -3522,7 +3522,7 @@ TEST_F(FileUtilTest, ReadFileToStringWithNamedPipe) {
+ }
+ #endif  // BUILDFLAG(IS_WIN)
+ 
+-#if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_APPLE)
++#if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_APPLE) && !BUILDFLAG(IS_BSD)
+ TEST_F(FileUtilTest, ReadFileToStringWithProcFileSystem) {
+   FilePath file_path("/proc/cpuinfo");
+   std::string data = "temp";
+@@ -4245,7 +4245,7 @@ TEST(FileUtilMultiThreadedTest, MultiThreadedTempFiles
+                 NULL);
+ #else
+     size_t bytes_written =
+-        ::write(::fileno(output_file.get()), content.c_str(), content.length());
++        ::write(fileno(output_file.get()), content.c_str(), content.length());
+ #endif
+     EXPECT_EQ(content.length(), bytes_written);
+     ::fflush(output_file.get());

www/ungoogled-chromium/files/patch-base_files_important__file__writer__cleaner.cc

@@ -0,0 +1,12 @@
+--- base/files/important_file_writer_cleaner.cc.orig	2022-10-01 07:40:07 UTC
++++ base/files/important_file_writer_cleaner.cc
+@@ -25,7 +25,8 @@ namespace base {
+ namespace {
+ 
+ base::Time GetUpperBoundTime() {
+-#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_IOS) || BUILDFLAG(IS_FUCHSIA)
++// needed because of .CreationTime() pledge
++#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_IOS) || BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_BSD)
+   // If process creation time is not available then use instance creation
+   // time as the upper-bound for old files. Modification times may be
+   // rounded-down to coarse-grained increments, e.g. FAT has 2s granularity,

www/ungoogled-chromium/files/patch-base_files_scoped__file.cc

@@ -0,0 +1,11 @@
+--- base/files/scoped_file.cc.orig	2022-10-01 07:40:07 UTC
++++ base/files/scoped_file.cc
+@@ -31,7 +31,7 @@ void ScopedFDCloseTraits::Free(int fd) {
+   int ret = IGNORE_EINTR(close(fd));
+ 
+ #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_APPLE) || \
+-    BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_ANDROID)
++    BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_BSD)
+   // NB: Some file descriptors can return errors from close() e.g. network
+   // filesystems such as NFS and Linux input devices. On Linux, macOS, and
+   // Fuchsia's POSIX layer, errors from close other than EBADF do not indicate

www/ungoogled-chromium/files/patch-base_i18n_icu__util.cc

@@ -0,0 +1,20 @@
+--- base/i18n/icu_util.cc.orig	2022-10-01 07:40:07 UTC
++++ base/i18n/icu_util.cc
+@@ -53,7 +53,7 @@
+ #include "third_party/icu/source/common/unicode/unistr.h"
+ #endif
+ 
+-#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_FUCHSIA) || \
++#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_BSD) || \
+     BUILDFLAG(IS_CHROMEOS) || (BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_CASTOS))
+ #include "third_party/icu/source/i18n/unicode/timezone.h"
+ #endif
+@@ -325,7 +325,7 @@ void InitializeIcuTimeZone() {
+       FuchsiaIntlProfileWatcher::GetPrimaryTimeZoneIdForIcuInitialization();
+   icu::TimeZone::adoptDefault(
+       icu::TimeZone::createTimeZone(icu::UnicodeString::fromUTF8(zone_id)));
+-#elif BUILDFLAG(IS_CHROMEOS) || (BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_CASTOS))
++#elif BUILDFLAG(IS_CHROMEOS) || (BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_CASTOS)) || BUILDFLAG(IS_BSD)
+   // To respond to the time zone change properly, the default time zone
+   // cache in ICU has to be populated on starting up.
+   // See TimeZoneMonitorLinux::NotifyClientsFromImpl().

www/ungoogled-chromium/files/patch-base_linux__util.cc

@@ -0,0 +1,28 @@
+--- base/linux_util.cc.orig	2022-10-01 07:40:07 UTC
++++ base/linux_util.cc
+@@ -15,6 +15,7 @@
+ 
+ #include <iomanip>
+ #include <memory>
++#include <sstream>
+ 
+ #include "base/base_export.h"
+ #include "base/files/dir_reader_posix.h"
+@@ -135,6 +136,9 @@ void SetLinuxDistro(const std::string& distro) {
+ }
+ 
+ bool GetThreadsForProcess(pid_t pid, std::vector<pid_t>* tids) {
++#if defined(OS_BSD)
++  return false;
++#else
+   // 25 > strlen("/proc//task") + strlen(std::to_string(INT_MAX)) + 1 = 22
+   char buf[25];
+   strings::SafeSPrintf(buf, "/proc/%d/task", pid);
+@@ -152,6 +156,7 @@ bool GetThreadsForProcess(pid_t pid, std::vector<pid_t
+   }
+ 
+   return true;
++#endif
+ }
+ 
+ pid_t FindThreadIDWithSyscall(pid_t pid, const std::string& expected_data,

www/ungoogled-chromium/files/patch-base_logging__unittest.cc

@@ -0,0 +1,31 @@
+--- base/logging_unittest.cc.orig	2022-10-01 07:40:07 UTC
++++ base/logging_unittest.cc
+@@ -32,7 +32,7 @@
+ #include "base/posix/eintr_wrapper.h"
+ #endif  // BUILDFLAG(IS_POSIX)
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_FREEBSD)
+ #include <ucontext.h>
+ #endif
+ 
+@@ -574,14 +574,18 @@ void CheckCrashTestSighandler(int, siginfo_t* info, vo
+   // need the arch-specific boilerplate below, which is inspired by breakpad.
+   // At the same time, on OSX, ucontext.h is deprecated but si_addr works fine.
+   uintptr_t crash_addr = 0;
+-#if BUILDFLAG(IS_MAC)
++#if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_FREEBSD)
+   crash_addr = reinterpret_cast<uintptr_t>(info->si_addr);
+ #else  // OS_*
+   ucontext_t* context = reinterpret_cast<ucontext_t*>(context_ptr);
+ #if defined(ARCH_CPU_X86)
+   crash_addr = static_cast<uintptr_t>(context->uc_mcontext.gregs[REG_EIP]);
+ #elif defined(ARCH_CPU_X86_64)
++#if BUILDFLAG(IS_OPENBSD)
++  crash_addr = static_cast<uintptr_t>(context->sc_rip);
++#else
+   crash_addr = static_cast<uintptr_t>(context->uc_mcontext.gregs[REG_RIP]);
++#endif
+ #elif defined(ARCH_CPU_ARMEL)
+   crash_addr = static_cast<uintptr_t>(context->uc_mcontext.arm_pc);
+ #elif defined(ARCH_CPU_ARM64)

www/ungoogled-chromium/files/patch-base_memory_discardable__memory.cc

@@ -0,0 +1,38 @@
+--- base/memory/discardable_memory.cc.orig	2022-10-01 07:40:07 UTC
++++ base/memory/discardable_memory.cc
+@@ -25,7 +25,7 @@ const base::Feature kMadvFreeDiscardableMemory{
+     "MadvFreeDiscardableMemory", base::FEATURE_DISABLED_BY_DEFAULT};
+ #endif  // BUILDFLAG(IS_POSIX)
+ 
+-#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ const base::Feature kDiscardableMemoryBackingTrial{
+     "DiscardableMemoryBackingTrial", base::FEATURE_DISABLED_BY_DEFAULT};
+ 
+@@ -50,7 +50,7 @@ const base::FeatureParam<DiscardableMemoryTrialGroup>
+ 
+ namespace {
+ 
+-#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ 
+ DiscardableMemoryBacking GetBackingForFieldTrial() {
+   DiscardableMemoryTrialGroup trial_group =
+@@ -69,7 +69,7 @@ DiscardableMemoryBacking GetBackingForFieldTrial() {
+ 
+ }  // namespace
+ 
+-#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ 
+ // Probe capabilities of this device to determine whether we should participate
+ // in the discardable memory backing trial.
+@@ -99,7 +99,7 @@ DiscardableMemory::DiscardableMemory() = default;
+ DiscardableMemory::~DiscardableMemory() = default;
+ 
+ DiscardableMemoryBacking GetDiscardableMemoryBacking() {
+-#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+   if (DiscardableMemoryBackingFieldTrialIsEnabled()) {
+     return GetBackingForFieldTrial();
+   }

www/ungoogled-chromium/files/patch-base_memory_discardable__memory__internal.h

@@ -0,0 +1,11 @@
+--- base/memory/discardable_memory_internal.h.orig	2022-10-01 07:40:07 UTC
++++ base/memory/discardable_memory_internal.h
+@@ -10,7 +10,7 @@
+ #include "base/metrics/field_trial_params.h"
+ #include "build/build_config.h"
+ 
+-#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ 
+ namespace base {
+ 

www/ungoogled-chromium/files/patch-base_memory_madv__free__discardable__memory__posix.cc

@@ -0,0 +1,21 @@
+--- base/memory/madv_free_discardable_memory_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/memory/madv_free_discardable_memory_posix.cc
+@@ -295,6 +295,10 @@ void MadvFreeDiscardableMemoryPosix::SetKeepMemoryForT
+ 
+ bool MadvFreeDiscardableMemoryPosix::IsResident() const {
+   DFAKE_SCOPED_RECURSIVE_LOCK(thread_collision_warner_);
++// XXX mincore
++#if BUILDFLAG(IS_BSD)
++  return false;
++#else
+ #if BUILDFLAG(IS_APPLE)
+   std::vector<char> vec(allocated_pages_);
+ #else
+@@ -310,6 +314,7 @@ bool MadvFreeDiscardableMemoryPosix::IsResident() cons
+       return false;
+   }
+   return true;
++#endif
+ }
+ 
+ bool MadvFreeDiscardableMemoryPosix::IsDiscarded() const {

www/ungoogled-chromium/files/patch-base_memory_platform__shared__memory__region.h

@@ -0,0 +1,29 @@
+--- base/memory/platform_shared_memory_region.h.orig	2022-10-01 07:40:07 UTC
++++ base/memory/platform_shared_memory_region.h
+@@ -16,7 +16,7 @@
+ 
+ #include <stdint.h>
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ namespace content {
+ class SandboxIPCHandler;
+ }
+@@ -83,7 +83,7 @@ class BASE_EXPORT PlatformSharedMemoryRegion {
+     kMaxValue = GET_SHMEM_TEMP_DIR_FAILURE
+   };
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+   // Structure to limit access to executable region creation.
+   struct ExecutableRegion {
+    private:
+@@ -211,7 +211,7 @@ class BASE_EXPORT PlatformSharedMemoryRegion {
+                            CheckPlatformHandlePermissionsCorrespondToMode);
+   static PlatformSharedMemoryRegion Create(Mode mode,
+                                            size_t size
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+                                            ,
+                                            bool executable = false
+ #endif

www/ungoogled-chromium/files/patch-base_memory_platform__shared__memory__region__posix.cc

@@ -0,0 +1,29 @@
+--- base/memory/platform_shared_memory_region_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/memory/platform_shared_memory_region_posix.cc
+@@ -55,7 +55,7 @@ bool CheckFDAccessMode(int fd, int expected_mode) {
+ 
+ }  // namespace
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ // static
+ ScopedFD PlatformSharedMemoryRegion::ExecutableRegion::CreateFD(size_t size) {
+   PlatformSharedMemoryRegion region =
+@@ -171,7 +171,7 @@ bool PlatformSharedMemoryRegion::ConvertToUnsafe() {
+ // static
+ PlatformSharedMemoryRegion PlatformSharedMemoryRegion::Create(Mode mode,
+                                                               size_t size
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+                                                               ,
+                                                               bool executable
+ #endif
+@@ -200,7 +200,7 @@ PlatformSharedMemoryRegion PlatformSharedMemoryRegion:
+   // flag.
+   FilePath directory;
+   if (!GetShmemTempDir(
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+           executable,
+ #else
+           false /* executable */,

www/ungoogled-chromium/files/patch-base_message__loop_message__pump__glib.cc

@@ -0,0 +1,28 @@
+--- base/message_loop/message_pump_glib.cc.orig	2022-10-01 07:40:07 UTC
++++ base/message_loop/message_pump_glib.cc
+@@ -8,6 +8,11 @@
+ #include <glib.h>
+ #include <math.h>
+ 
++#if BUILDFLAG(IS_BSD)
++#include <pthread.h>
++#include <pthread_np.h>
++#endif
++
+ #include "base/logging.h"
+ #include "base/memory/raw_ptr.h"
+ #include "base/notreached.h"
+@@ -51,9 +56,13 @@ int GetTimeIntervalMilliseconds(TimeTicks next_task_ti
+ }
+ 
+ bool RunningOnMainThread() {
++#if BUILDFLAG(IS_BSD)
++  return pthread_main_np();
++#else
+   auto pid = getpid();
+   auto tid = PlatformThread::CurrentId();
+   return pid > 0 && tid > 0 && pid == tid;
++#endif
+ }
+ 
+ // A brief refresher on GLib:

www/ungoogled-chromium/files/patch-base_native__library__posix.cc

@@ -0,0 +1,11 @@
+--- base/native_library_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/native_library_posix.cc
+@@ -33,7 +33,7 @@ NativeLibrary LoadNativeLibraryWithOptions(const FileP
+   // http://crbug.com/17943, http://crbug.com/17557, http://crbug.com/36892,
+   // and http://crbug.com/40794.
+   int flags = RTLD_LAZY;
+-#if BUILDFLAG(IS_ANDROID) || !defined(RTLD_DEEPBIND)
++#if BUILDFLAG(IS_ANDROID) || !defined(RTLD_DEEPBIND) || BUILDFLAG(IS_BSD)
+   // Certain platforms don't define RTLD_DEEPBIND. Android dlopen() requires
+   // further investigation, as it might vary across versions. Crash here to
+   // warn developers that they're trying to rely on uncertain behavior.

www/ungoogled-chromium/files/patch-base_native__library__unittest.cc

@@ -0,0 +1,11 @@
+--- base/native_library_unittest.cc.orig	2022-10-01 07:40:07 UTC
++++ base/native_library_unittest.cc
+@@ -119,7 +119,7 @@ TEST(NativeLibraryTest, LoadLibrary) {
+ // versions with respect to symbol resolution scope.
+ // TSan and MSan error out on RTLD_DEEPBIND, https://crbug.com/705255
+ #if !BUILDFLAG(IS_ANDROID) && !defined(THREAD_SANITIZER) && \
+-    !defined(MEMORY_SANITIZER)
++    !defined(MEMORY_SANITIZER) && !BUILDFLAG(IS_BSD)
+ 
+ // Verifies that the |prefer_own_symbols| option satisfies its guarantee that
+ // a loaded library will always prefer local symbol resolution before

www/ungoogled-chromium/files/patch-base_posix_can__lower__nice__to.cc

@@ -0,0 +1,16 @@
+--- base/posix/can_lower_nice_to.cc.orig	2022-10-01 07:40:07 UTC
++++ base/posix/can_lower_nice_to.cc
+@@ -11,8 +11,12 @@
+ 
+ #include "build/build_config.h"
+ 
++#if BUILDFLAG(IS_FREEBSD)
++#include <sys/param.h>
++#endif
++
+ // Not defined on AIX by default.
+-#if BUILDFLAG(IS_AIX)
++#if BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+ #if defined(RLIMIT_NICE)
+ #error Assumption about OS_AIX is incorrect
+ #endif

www/ungoogled-chromium/files/patch-base_posix_unix__domain__socket.cc

@@ -0,0 +1,39 @@
+--- base/posix/unix_domain_socket.cc.orig	2022-10-01 07:40:07 UTC
++++ base/posix/unix_domain_socket.cc
+@@ -51,7 +51,7 @@ bool CreateSocketPair(ScopedFD* one, ScopedFD* two) {
+ 
+ // static
+ bool UnixDomainSocket::EnableReceiveProcessId(int fd) {
+-#if !BUILDFLAG(IS_APPLE)
++#if !BUILDFLAG(IS_APPLE) && !BUILDFLAG(IS_BSD)
+   const int enable = 1;
+   return setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable)) == 0;
+ #else
+@@ -149,7 +149,7 @@ ssize_t UnixDomainSocket::RecvMsgWithFlags(int fd,
+ 
+   const size_t kControlBufferSize =
+       CMSG_SPACE(sizeof(int) * kMaxFileDescriptors)
+-#if !BUILDFLAG(IS_APPLE)
++#if !BUILDFLAG(IS_APPLE) && !BUILDFLAG(IS_BSD)
+       // macOS does not support ucred.
+       // macOS supports xucred, but this structure is insufficient.
+       + CMSG_SPACE(sizeof(struct ucred))
+@@ -177,7 +177,7 @@ ssize_t UnixDomainSocket::RecvMsgWithFlags(int fd,
+         wire_fds = reinterpret_cast<int*>(CMSG_DATA(cmsg));
+         wire_fds_len = payload_len / sizeof(int);
+       }
+-#if !BUILDFLAG(IS_APPLE)
++#if !BUILDFLAG(IS_APPLE) && !BUILDFLAG(IS_BSD)
+       // macOS does not support SCM_CREDENTIALS.
+       if (cmsg->cmsg_level == SOL_SOCKET &&
+           cmsg->cmsg_type == SCM_CREDENTIALS) {
+@@ -211,6 +211,9 @@ ssize_t UnixDomainSocket::RecvMsgWithFlags(int fd,
+     socklen_t pid_size = sizeof(pid);
+     if (getsockopt(fd, SOL_LOCAL, LOCAL_PEERPID, &pid, &pid_size) != 0)
+       pid = -1;
++#elif BUILDFLAG(IS_BSD)
++    NOTIMPLEMENTED();
++    pid = -1;
+ #else
+     // |pid| will legitimately be -1 if we read EOF, so only DCHECK if we
+     // actually received a message.  Unfortunately, Linux allows sending zero

www/ungoogled-chromium/files/patch-base_posix_unix__domain__socket__unittest.cc

@@ -0,0 +1,11 @@
+--- base/posix/unix_domain_socket_unittest.cc.orig	2022-10-01 07:40:07 UTC
++++ base/posix/unix_domain_socket_unittest.cc
+@@ -10,6 +10,8 @@
+ #include <sys/types.h>
+ #include <unistd.h>
+ 
++#include <signal.h>
++
+ #include "base/bind.h"
+ #include "base/callback_helpers.h"
+ #include "base/files/file_util.h"

www/ungoogled-chromium/files/patch-base_process_kill.h

@@ -0,0 +1,11 @@
+--- base/process/kill.h.orig	2022-10-01 07:40:07 UTC
++++ base/process/kill.h
+@@ -113,7 +113,7 @@ BASE_EXPORT TerminationStatus GetTerminationStatus(Pro
+ BASE_EXPORT TerminationStatus GetKnownDeadTerminationStatus(
+     ProcessHandle handle, int* exit_code);
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ // Spawns a thread to wait asynchronously for the child |process| to exit
+ // and then reaps it.
+ BASE_EXPORT void EnsureProcessGetsReaped(Process process);

www/ungoogled-chromium/files/patch-base_process_kill__posix.cc

@@ -0,0 +1,11 @@
+--- base/process/kill_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/kill_posix.cc
+@@ -158,7 +158,7 @@ void EnsureProcessTerminated(Process process) {
+       0, new BackgroundReaper(std::move(process), Seconds(2)));
+ }
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ void EnsureProcessGetsReaped(Process process) {
+   DCHECK(!process.is_current());
+ 

www/ungoogled-chromium/files/patch-base_process_launch.h

@@ -0,0 +1,11 @@
+--- base/process/launch.h.orig	2022-10-01 07:40:07 UTC
++++ base/process/launch.h
+@@ -198,7 +198,7 @@ struct BASE_EXPORT LaunchOptions {
+   bool clear_environment = false;
+ #endif  // BUILDFLAG(IS_WIN) || BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+   // If non-zero, start the process using clone(), using flags as provided.
+   // Unlike in clone, clone_flags may not contain a custom termination signal
+   // that is sent to the parent when the child dies. The termination signal will

www/ungoogled-chromium/files/patch-base_process_launch__posix.cc

@@ -0,0 +1,12 @@
+--- base/process/launch_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/launch_posix.cc
+@@ -64,6 +64,9 @@
+ #error "macOS should use launch_mac.cc"
+ #endif
+ 
++#if defined(OS_FREEBSD)
++#pragma weak environ
++#endif
+ extern char** environ;
+ 
+ namespace base {

www/ungoogled-chromium/files/patch-base_process_memory.cc

@@ -0,0 +1,11 @@
+--- base/process/memory.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/memory.cc
+@@ -29,7 +29,7 @@ namespace base {
+ // Defined in memory_mac.mm for macOS + use_allocator="none".  In case of
+ // USE_PARTITION_ALLOC_AS_MALLOC, no need to route the call to the system
+ // default calloc of macOS.
+-#if !BUILDFLAG(IS_APPLE) || BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
++#if (!BUILDFLAG(IS_APPLE) && !BUILDFLAG(IS_BSD)) || BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
+ 
+ bool UncheckedCalloc(size_t num_items, size_t size, void** result) {
+   const size_t alloc_size = num_items * size;

www/ungoogled-chromium/files/patch-base_process_process__handle.cc

@@ -0,0 +1,11 @@
+--- base/process/process_handle.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_handle.cc
+@@ -30,7 +30,7 @@ UniqueProcId GetUniqueIdForProcess() {
+              : UniqueProcId(GetCurrentProcId());
+ }
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_AIX)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+ 
+ void InitUniqueIdForProcessInPidNamespace(ProcessId pid_outside_of_namespace) {
+   DCHECK(pid_outside_of_namespace != kNullProcessId);

www/ungoogled-chromium/files/patch-base_process_process__handle.h

@@ -0,0 +1,11 @@
+--- base/process/process_handle.h.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_handle.h
+@@ -106,7 +106,7 @@ BASE_EXPORT ProcessId GetCurrentProcId();
+ // processes may be reused.
+ BASE_EXPORT UniqueProcId GetUniqueIdForProcess();
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ // When a process is started in a different PID namespace from the browser
+ // process, this function must be called with the process's PID in the browser's
+ // PID namespace in order to initialize its unique ID. Not thread safe.

www/ungoogled-chromium/files/patch-base_process_process__handle__freebsd.cc

@@ -0,0 +1,25 @@
+--- base/process/process_handle_freebsd.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_handle_freebsd.cc
+@@ -3,6 +3,7 @@
+ // found in the LICENSE file.
+ 
+ #include "base/process/process_handle.h"
++#include "base/files/file_util.h"
+ 
+ #include <limits.h>
+ #include <stddef.h>
+@@ -15,10 +16,13 @@ namespace base {
+ 
+ ProcessId GetParentProcessId(ProcessHandle process) {
+   struct kinfo_proc info;
+-  size_t length;
++  size_t length = sizeof(struct kinfo_proc);
+   int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, process };
+ 
+   if (sysctl(mib, std::size(mib), &info, &length, NULL, 0) < 0)
++    return -1;
++
++  if (length < sizeof(struct kinfo_proc))
+     return -1;
+ 
+   return info.ki_ppid;

www/ungoogled-chromium/files/patch-base_process_process__handle__openbsd.cc

@@ -0,0 +1,89 @@
+--- base/process/process_handle_openbsd.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_handle_openbsd.cc
+@@ -3,8 +3,11 @@
+ // found in the LICENSE file.
+ 
+ #include "base/process/process_handle.h"
++#include "base/files/file_util.h"
+ 
+ #include <stddef.h>
++#include <sys/param.h>
++#include <sys/proc.h>
+ #include <sys/sysctl.h>
+ #include <sys/types.h>
+ #include <unistd.h>
+@@ -12,39 +15,59 @@
+ namespace base {
+ 
+ ProcessId GetParentProcessId(ProcessHandle process) {
+-  struct kinfo_proc info;
++  struct kinfo_proc *info;
+   size_t length;
++  pid_t ppid;
+   int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, process,
+                 sizeof(struct kinfo_proc), 0 };
+ 
+   if (sysctl(mib, std::size(mib), NULL, &length, NULL, 0) < 0)
+     return -1;
+ 
++  info = (struct kinfo_proc *)malloc(length);
++
+   mib[5] = (length / sizeof(struct kinfo_proc));
+ 
+-  if (sysctl(mib, std::size(mib), &info, &length, NULL, 0) < 0)
+-    return -1;
++  if (sysctl(mib, std::size(mib), info, &length, NULL, 0) < 0) {
++    ppid = -1;
++    goto out;
++  }
+ 
+-  return info.p_ppid;
++  ppid = info->p_ppid;
++
++out:
++  free(info);
++  return ppid;
+ }
+ 
+ FilePath GetProcessExecutablePath(ProcessHandle process) {
+-  struct kinfo_proc kp;
+-  size_t len;
++  struct kinfo_proc *info;
++  size_t length;
++  char *path = NULL;
+   int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, process,
+                 sizeof(struct kinfo_proc), 0 };
+ 
+-  if (sysctl(mib, std::size(mib), NULL, &len, NULL, 0) == -1)
++  if (sysctl(mib, std::size(mib), NULL, &length, NULL, 0) == -1)
+     return FilePath();
+-  mib[5] = (len / sizeof(struct kinfo_proc));
+-  if (sysctl(mib, std::size(mib), &kp, &len, NULL, 0) < 0)
+-    return FilePath();
+-  if ((kp.p_flag & P_SYSTEM) != 0)
+-    return FilePath();
+-  if (strcmp(kp.p_comm, "chrome") == 0)
+-    return FilePath(kp.p_comm);
+ 
+-  return FilePath();
++  info = (struct kinfo_proc *)malloc(length);
++
++  mib[5] = (length / sizeof(struct kinfo_proc));
++
++  if (sysctl(mib, std::size(mib), info, &length, NULL, 0) < 0)
++    goto out;
++
++  if ((info->p_flag & P_SYSTEM) != 0)
++    goto out;
++
++  if (strcmp(info->p_comm, "chrome") == 0) {
++    path = info->p_comm;
++    goto out;
++  }
++
++out:
++  free(info);
++  return FilePath(path);
+ }
+ 
+ }  // namespace base

www/ungoogled-chromium/files/patch-base_process_process__iterator__freebsd.cc

@@ -0,0 +1,51 @@
+--- base/process/process_iterator_freebsd.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_iterator_freebsd.cc
+@@ -20,7 +20,7 @@ ProcessIterator::ProcessIterator(const ProcessFilter* 
+     : index_of_kinfo_proc_(),
+       filter_(filter) {
+ 
+-  int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_UID, getuid() };
++  int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_UID, (int) getuid() };
+ 
+   bool done = false;
+   int try_num = 1;
+@@ -39,7 +39,7 @@ ProcessIterator::ProcessIterator(const ProcessFilter* 
+       num_of_kinfo_proc += 16;
+       kinfo_procs_.resize(num_of_kinfo_proc);
+       len = num_of_kinfo_proc * sizeof(struct kinfo_proc);
+-      if (sysctl(mib, std::size(mib), &kinfo_procs_[0], &len, NULL, 0) < 0) {
++      if (sysctl(mib, std::size(mib), kinfo_procs_.data(), &len, NULL, 0) < 0) {
+         // If we get a mem error, it just means we need a bigger buffer, so
+         // loop around again.  Anything else is a real error and give up.
+         if (errno != ENOMEM) {
+@@ -49,7 +49,7 @@ ProcessIterator::ProcessIterator(const ProcessFilter* 
+         }
+       } else {
+         // Got the list, just make sure we're sized exactly right
+-        size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
++	num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
+         kinfo_procs_.resize(num_of_kinfo_proc);
+         done = true;
+       }
+@@ -71,18 +71,13 @@ bool ProcessIterator::CheckForNextProcess() {
+   for (; index_of_kinfo_proc_ < kinfo_procs_.size(); ++index_of_kinfo_proc_) {
+     size_t length;
+     struct kinfo_proc kinfo = kinfo_procs_[index_of_kinfo_proc_];
+-    int mib[] = { CTL_KERN, KERN_PROC_ARGS, kinfo.ki_pid };
++    int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_ARGS, kinfo.ki_pid };
+ 
+     if ((kinfo.ki_pid > 0) && (kinfo.ki_stat == SZOMB))
+       continue;
+ 
+-    length = 0;
+-    if (sysctl(mib, std::size(mib), NULL, &length, NULL, 0) < 0) {
+-      LOG(ERROR) << "failed to figure out the buffer size for a command line";
+-      continue;
+-    }
+-
+-    data.resize(length);
++    data.resize(ARG_MAX);
++    length = ARG_MAX;
+ 
+     if (sysctl(mib, std::size(mib), &data[0], &length, NULL, 0) < 0) {
+       LOG(ERROR) << "failed to fetch a commandline";

www/ungoogled-chromium/files/patch-base_process_process__iterator__openbsd.cc

@@ -0,0 +1,45 @@
+--- base/process/process_iterator_openbsd.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_iterator_openbsd.cc
+@@ -6,6 +6,9 @@
+ 
+ #include <errno.h>
+ #include <stddef.h>
++#include <unistd.h>
++#include <sys/param.h>
++#include <sys/proc.h>
+ #include <sys/sysctl.h>
+ 
+ #include "base/logging.h"
+@@ -18,12 +21,13 @@ ProcessIterator::ProcessIterator(const ProcessFilter* 
+     : index_of_kinfo_proc_(),
+       filter_(filter) {
+ 
+-  int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_UID, getuid(),
++  int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_UID, static_cast<int>(getuid()),
+                 sizeof(struct kinfo_proc), 0 };
+ 
+   bool done = false;
+   int try_num = 1;
+   const int max_tries = 10;
++  size_t num_of_kinfo_proc;
+ 
+   do {
+     size_t len = 0;
+@@ -32,7 +36,7 @@ ProcessIterator::ProcessIterator(const ProcessFilter* 
+       kinfo_procs_.resize(0);
+       done = true;
+     } else {
+-      size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
++      num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
+       // Leave some spare room for process table growth (more could show up
+       // between when we check and now)
+       num_of_kinfo_proc += 16;
+@@ -48,7 +52,7 @@ ProcessIterator::ProcessIterator(const ProcessFilter* 
+         }
+       } else {
+         // Got the list, just make sure we're sized exactly right
+-        size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
++        num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
+         kinfo_procs_.resize(num_of_kinfo_proc);
+         done = true;
+       }

www/ungoogled-chromium/files/patch-base_process_process__metrics.cc

@@ -0,0 +1,47 @@
+--- base/process/process_metrics.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_metrics.cc
+@@ -17,7 +17,7 @@ namespace base {
+ namespace {
+ 
+ #if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || \
+-    BUILDFLAG(IS_AIX)
++    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+ int CalculateEventsPerSecond(uint64_t event_count,
+                              uint64_t* last_event_count,
+                              base::TimeTicks* last_calculated) {
+@@ -54,7 +54,7 @@ SystemMetrics SystemMetrics::Sample() {
+   SystemMetrics system_metrics;
+ 
+   system_metrics.committed_memory_ = GetSystemCommitCharge();
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_BSD)
+   GetSystemMemoryInfo(&system_metrics.memory_info_);
+   GetVmStatInfo(&system_metrics.vmstat_info_);
+   GetSystemDiskInfo(&system_metrics.disk_info_);
+@@ -73,7 +73,7 @@ Value SystemMetrics::ToValue() const {
+   Value res(Value::Type::DICTIONARY);
+ 
+   res.SetIntKey("committed_memory", static_cast<int>(committed_memory_));
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_BSD)
+   Value meminfo = memory_info_.ToValue();
+   Value vmstat = vmstat_info_.ToValue();
+   meminfo.MergeDictionary(&vmstat);
+@@ -99,7 +99,7 @@ std::unique_ptr<ProcessMetrics> ProcessMetrics::Create
+ #endif  // !BUILDFLAG(IS_MAC)
+ }
+ 
+-#if !BUILDFLAG(IS_FREEBSD) || !BUILDFLAG(IS_POSIX)
++#if !BUILDFLAG(IS_FREEBSD)
+ double ProcessMetrics::GetPlatformIndependentCPUUsage() {
+   TimeDelta cumulative_cpu = GetCumulativeCPUUsage();
+   TimeTicks time = TimeTicks::Now();
+@@ -150,7 +150,7 @@ double ProcessMetrics::GetPreciseCPUUsage() {
+ #endif  // BUILDFLAG(IS_WIN)
+ 
+ #if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || \
+-    BUILDFLAG(IS_AIX)
++    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+ int ProcessMetrics::CalculateIdleWakeupsPerSecond(
+     uint64_t absolute_idle_wakeups) {
+   return CalculateEventsPerSecond(absolute_idle_wakeups,

www/ungoogled-chromium/files/patch-base_process_process__metrics.h

@@ -0,0 +1,129 @@
+--- base/process/process_metrics.h.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_metrics.h
+@@ -36,7 +36,7 @@
+ #endif
+ 
+ #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || \
+-    BUILDFLAG(IS_AIX)
++    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+ #include <string>
+ #include <utility>
+ #include <vector>
+@@ -52,7 +52,7 @@ class Value;
+ // Full declaration is in process_metrics_iocounters.h.
+ struct IoCounters;
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_BSD)
+ // Minor and major page fault counts since the process creation.
+ // Both counts are process-wide, and exclude child processes.
+ //
+@@ -107,7 +107,7 @@ class BASE_EXPORT ProcessMetrics {
+   // convenience wrapper for CreateProcessMetrics().
+   static std::unique_ptr<ProcessMetrics> CreateCurrentProcessMetrics();
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_BSD)
+   // Resident Set Size is a Linux/Android specific memory concept. Do not
+   // attempt to extend this to other platforms.
+   BASE_EXPORT size_t GetResidentSetSize() const;
+@@ -155,7 +155,7 @@ class BASE_EXPORT ProcessMetrics {
+ #endif  // BUILDFLAG(IS_WIN)
+ 
+ #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || \
+-    BUILDFLAG(IS_AIX)
++    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+   // Emits the cumulative CPU usage for all currently active threads since they
+   // were started into the output parameter (replacing its current contents).
+   // Threads that have already terminated will not be reported. Thus, the sum of
+@@ -238,7 +238,7 @@ class BASE_EXPORT ProcessMetrics {
+   int GetOpenFdSoftLimit() const;
+ #endif  // BUILDFLAG(IS_POSIX)
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_BSD)
+   // Bytes of swap as reported by /proc/[pid]/status.
+   uint64_t GetVmSwapBytes() const;
+ 
+@@ -259,7 +259,7 @@ class BASE_EXPORT ProcessMetrics {
+ #endif  // !BUILDFLAG(IS_MAC)
+ 
+ #if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || \
+-    BUILDFLAG(IS_AIX)
++    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+   int CalculateIdleWakeupsPerSecond(uint64_t absolute_idle_wakeups);
+ #endif
+ #if BUILDFLAG(IS_APPLE)
+@@ -270,7 +270,7 @@ class BASE_EXPORT ProcessMetrics {
+ #endif
+ 
+ #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || \
+-    BUILDFLAG(IS_AIX)
++    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+   CPU::CoreType GetCoreType(uint32_t core_index);
+ #endif  // BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) ||
+         // BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_AIX)
+@@ -284,9 +284,7 @@ class BASE_EXPORT ProcessMetrics {
+   // Used to store the previous times and CPU usage counts so we can
+   // compute the CPU usage between calls.
+   TimeTicks last_cpu_time_;
+-#if !BUILDFLAG(IS_FREEBSD) || !BUILDFLAG(IS_POSIX)
+   TimeDelta last_cumulative_cpu_;
+-#endif
+ 
+ #if BUILDFLAG(IS_WIN)
+   TimeTicks last_cpu_time_for_precise_cpu_usage_;
+@@ -294,7 +292,7 @@ class BASE_EXPORT ProcessMetrics {
+ #endif
+ 
+ #if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || \
+-    BUILDFLAG(IS_AIX)
++    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+   // Same thing for idle wakeups.
+   TimeTicks last_idle_wakeups_time_;
+   uint64_t last_absolute_idle_wakeups_;
+@@ -337,7 +335,7 @@ BASE_EXPORT void IncreaseFdLimitTo(unsigned int max_de
+ 
+ #if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_LINUX) ||      \
+     BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_AIX) || \
+-    BUILDFLAG(IS_FUCHSIA)
++    BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_BSD)
+ // Data about system-wide memory consumption. Values are in KB. Available on
+ // Windows, Mac, Linux, Android and Chrome OS.
+ //
+@@ -372,7 +370,7 @@ struct BASE_EXPORT SystemMemoryInfoKB {
+ #endif
+ 
+ #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || \
+-    BUILDFLAG(IS_AIX)
++    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+   // This provides an estimate of available memory as described here:
+   // https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=34e431b0ae398fc54ea69ff85ec700722c9da773
+   // NOTE: this is ONLY valid in kernels 3.14 and up.  Its value will always
+@@ -387,7 +385,7 @@ struct BASE_EXPORT SystemMemoryInfoKB {
+ #endif
+ 
+ #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || \
+-    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_FUCHSIA)
++    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_BSD)
+   int buffers = 0;
+   int cached = 0;
+   int active_anon = 0;
+@@ -424,7 +422,7 @@ BASE_EXPORT bool GetSystemMemoryInfo(SystemMemoryInfoK
+         // BUILDFLAG(IS_FUCHSIA)
+ 
+ #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || \
+-    BUILDFLAG(IS_AIX)
++    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+ // Parse the data found in /proc/<pid>/stat and return the sum of the
+ // CPU-related ticks.  Returns -1 on parse error.
+ // Exposed for testing.
+@@ -611,7 +609,7 @@ class BASE_EXPORT SystemMetrics {
+   FRIEND_TEST_ALL_PREFIXES(SystemMetricsTest, SystemMetrics);
+ 
+   size_t committed_memory_;
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_BSD)
+   SystemMemoryInfoKB memory_info_;
+   VmStatInfo vmstat_info_;
+   SystemDiskInfo disk_info_;

www/ungoogled-chromium/files/patch-base_process_process__metrics__freebsd.cc

@@ -0,0 +1,290 @@
+--- base/process/process_metrics_freebsd.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_metrics_freebsd.cc
+@@ -3,20 +3,39 @@
+ // found in the LICENSE file.
+ 
+ #include "base/process/process_metrics.h"
++#include "base/notreached.h"
+ 
+ #include <stddef.h>
++#include <sys/types.h>
+ #include <sys/sysctl.h>
+ #include <sys/user.h>
+ #include <unistd.h>
+ 
++#include <fcntl.h> /* O_RDONLY */
++#include <kvm.h>
++#include <libutil.h>
++
+ #include "base/memory/ptr_util.h"
+ #include "base/process/process_metrics_iocounters.h"
++#include "base/values.h"
+ 
+ namespace base {
++namespace {
++int GetPageShift() {
++  int pagesize = getpagesize();
++  int pageshift = 0;
+ 
++  while (pagesize > 1) {
++    pageshift++;
++    pagesize >>= 1;
++  }
++
++  return pageshift;
++}
++}
++
+ ProcessMetrics::ProcessMetrics(ProcessHandle process)
+-    : process_(process),
+-      last_cpu_(0) {}
++    : process_(process) {}
+ 
+ // static
+ std::unique_ptr<ProcessMetrics> ProcessMetrics::CreateProcessMetrics(
+@@ -26,17 +45,18 @@ std::unique_ptr<ProcessMetrics> ProcessMetrics::Create
+ 
+ double ProcessMetrics::GetPlatformIndependentCPUUsage() {
+   struct kinfo_proc info;
+-  int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, process_};
+-  size_t length = sizeof(info);
++  size_t length = sizeof(struct kinfo_proc);
+ 
++  int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, process_ };
++
+   if (sysctl(mib, std::size(mib), &info, &length, NULL, 0) < 0)
+-    return 0;
++    return 0.0;
+ 
+-  return (info.ki_pctcpu / FSCALE) * 100.0;
++  return static_cast<double>((info.ki_pctcpu * 100.0) / FSCALE);
+ }
+ 
+ TimeDelta ProcessMetrics::GetCumulativeCPUUsage() {
+-  NOTREACHED();
++  NOTIMPLEMENTED();
+   return TimeDelta();
+ }
+ 
+@@ -67,4 +87,221 @@ size_t GetSystemCommitCharge() {
+   return mem_total - (mem_free*pagesize) - (mem_inactive*pagesize);
+ }
+ 
++int64_t GetNumberOfThreads(ProcessHandle process) {
++  // Taken from FreeBSD top (usr.bin/top/machine.c)
++
++  kvm_t* kd = kvm_open(NULL, "/dev/null", NULL, O_RDONLY, "kvm_open");
++  if (kd == NULL)
++    return 0;
++
++  struct kinfo_proc* pbase;
++  int nproc;
++  pbase = kvm_getprocs(kd, KERN_PROC_PID, process, &nproc);
++  if (pbase == NULL)
++    return 0;
++
++  if (kvm_close(kd) == -1)
++    return 0;
++
++  return nproc;
++}
++
++bool GetSystemMemoryInfo(SystemMemoryInfoKB *meminfo) {
++  unsigned int mem_total, mem_free, swap_total, swap_used;
++  size_t length;
++  int pagesizeKB;
++
++  pagesizeKB = getpagesize() / 1024;
++
++  length = sizeof(mem_total);
++  if (sysctlbyname("vm.stats.vm.v_page_count", &mem_total,
++      &length, NULL, 0) != 0 || length != sizeof(mem_total))
++    return false;
++
++  length = sizeof(mem_free);
++  if (sysctlbyname("vm.stats.vm.v_free_count", &mem_free, &length, NULL, 0)
++      != 0 || length != sizeof(mem_free))
++    return false;
++
++  length = sizeof(swap_total);
++  if (sysctlbyname("vm.swap_size", &swap_total, &length, NULL, 0)
++      != 0 || length != sizeof(swap_total))
++    return false;
++
++  length = sizeof(swap_used);
++  if (sysctlbyname("vm.swap_anon_use", &swap_used, &length, NULL, 0)
++      != 0 || length != sizeof(swap_used))
++    return false;
++
++  meminfo->total = mem_total * pagesizeKB;
++  meminfo->free = mem_free * pagesizeKB;
++  meminfo->swap_total = swap_total * pagesizeKB;
++  meminfo->swap_free = (swap_total - swap_used) * pagesizeKB;
++
++  return true;
++}
++
++int ProcessMetrics::GetOpenFdCount() const {
++  struct kinfo_file * kif;
++  int cnt;
++
++  if ((kif = kinfo_getfile(process_, &cnt)) == NULL)
++    return -1;
++
++  free(kif);
++
++  return cnt;
++}
++
++int ProcessMetrics::GetOpenFdSoftLimit() const {
++  size_t length;
++  int total_count = 0;
++  int mib[] = { CTL_KERN, KERN_MAXFILESPERPROC };
++
++  length = sizeof(total_count);
++
++  if (sysctl(mib, std::size(mib), &total_count, &length, NULL, 0) < 0) {
++    total_count = -1;
++  }
++
++  return total_count;
++}
++
++size_t ProcessMetrics::GetResidentSetSize() const {
++  kvm_t *kd = kvm_open(nullptr, "/dev/null", nullptr, O_RDONLY, "kvm_open");
++
++  if (kd == nullptr)
++    return 0;
++
++  struct kinfo_proc *pp;
++  int nproc;
++
++  if ((pp = kvm_getprocs(kd, KERN_PROC_PID, process_, &nproc)) == nullptr) {
++    kvm_close(kd);
++    return 0;
++  }
++  
++  size_t rss;
++
++  if (nproc > 0) {
++    rss = pp->ki_rssize << GetPageShift();
++  } else {
++    rss = 0;
++  }
++
++  kvm_close(kd);
++  return rss;
++}
++
++uint64_t ProcessMetrics::GetVmSwapBytes() const {
++  kvm_t *kd = kvm_open(nullptr, "/dev/null", nullptr, O_RDONLY, "kvm_open");
++
++  if (kd == nullptr)
++    return 0;
++
++  struct kinfo_proc *pp;
++  int nproc;
++
++  if ((pp = kvm_getprocs(kd, KERN_PROC_PID, process_, &nproc)) == nullptr) {
++    kvm_close(kd);
++    return 0;
++  }
++  
++  size_t swrss;
++
++  if (nproc > 0) {
++    swrss = pp->ki_swrss > pp->ki_rssize
++      ? (pp->ki_swrss - pp->ki_rssize) << GetPageShift()
++      : 0;
++  } else {
++    swrss = 0;
++  }
++
++  kvm_close(kd);
++  return swrss;
++}
++
++int ProcessMetrics::GetIdleWakeupsPerSecond() {
++  NOTIMPLEMENTED();
++  return 0;
++}
++
++bool GetSystemDiskInfo(SystemDiskInfo* diskinfo) {
++  NOTIMPLEMENTED();
++  return false;
++}
++
++bool GetVmStatInfo(VmStatInfo* vmstat) {
++  NOTIMPLEMENTED();
++  return false;
++}
++
++SystemDiskInfo::SystemDiskInfo() {
++  reads = 0;
++  reads_merged = 0;
++  sectors_read = 0;
++  read_time = 0;
++  writes = 0;
++  writes_merged = 0;
++  sectors_written = 0;
++  write_time = 0;
++  io = 0;
++  io_time = 0;
++  weighted_io_time = 0;
++}
++
++SystemDiskInfo::SystemDiskInfo(const SystemDiskInfo& other) = default;
++
++SystemDiskInfo& SystemDiskInfo::operator=(const SystemDiskInfo&) = default;
++
++Value SystemDiskInfo::ToValue() const {
++  Value res(Value::Type::DICTIONARY);
++
++  // Write out uint64_t variables as doubles.
++  // Note: this may discard some precision, but for JS there's no other option.
++  res.SetDoubleKey("reads", static_cast<double>(reads));
++  res.SetDoubleKey("reads_merged", static_cast<double>(reads_merged));
++  res.SetDoubleKey("sectors_read", static_cast<double>(sectors_read));
++  res.SetDoubleKey("read_time", static_cast<double>(read_time));
++  res.SetDoubleKey("writes", static_cast<double>(writes));
++  res.SetDoubleKey("writes_merged", static_cast<double>(writes_merged));
++  res.SetDoubleKey("sectors_written", static_cast<double>(sectors_written));
++  res.SetDoubleKey("write_time", static_cast<double>(write_time));
++  res.SetDoubleKey("io", static_cast<double>(io));
++  res.SetDoubleKey("io_time", static_cast<double>(io_time));
++  res.SetDoubleKey("weighted_io_time", static_cast<double>(weighted_io_time));
++
++  return res;
++}
++
++Value SystemMemoryInfoKB::ToValue() const {
++  Value res(Value::Type::DICTIONARY);
++
++  res.SetIntKey("total", total);
++  res.SetIntKey("free", free);
++  res.SetIntKey("available", available);
++  res.SetIntKey("buffers", buffers);
++  res.SetIntKey("cached", cached);
++  res.SetIntKey("active_anon", active_anon);
++  res.SetIntKey("inactive_anon", inactive_anon);
++  res.SetIntKey("active_file", active_file);
++  res.SetIntKey("inactive_file", inactive_file);
++  res.SetIntKey("swap_total", swap_total);
++  res.SetIntKey("swap_free", swap_free);
++  res.SetIntKey("swap_used", swap_total - swap_free);
++  res.SetIntKey("dirty", dirty);
++  res.SetIntKey("reclaimable", reclaimable);
++
++  return res;
++}
++
++Value VmStatInfo::ToValue() const {
++  Value res(Value::Type::DICTIONARY);
++
++  res.SetIntKey("pswpin", pswpin);
++  res.SetIntKey("pswpout", pswpout);
++  res.SetIntKey("pgmajfault", pgmajfault);
++
++  return res;
++}
+ }  // namespace base

www/ungoogled-chromium/files/patch-base_process_process__metrics__openbsd.cc

@@ -0,0 +1,215 @@
+--- base/process/process_metrics_openbsd.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_metrics_openbsd.cc
+@@ -6,14 +6,23 @@
+ 
+ #include <stddef.h>
+ #include <stdint.h>
++#include <fcntl.h>
+ #include <sys/param.h>
+ #include <sys/sysctl.h>
++#include <sys/vmmeter.h>
+ 
++#include <kvm.h>
++
+ #include "base/memory/ptr_util.h"
+ #include "base/process/process_metrics_iocounters.h"
++#include "base/values.h"
++#include "base/notreached.h"
+ 
+ namespace base {
+ 
++ProcessMetrics::ProcessMetrics(ProcessHandle process)
++    : process_(process) {}
++
+ // static
+ std::unique_ptr<ProcessMetrics> ProcessMetrics::CreateProcessMetrics(
+     ProcessHandle process) {
+@@ -24,49 +33,23 @@ bool ProcessMetrics::GetIOCounters(IoCounters* io_coun
+   return false;
+ }
+ 
+-static int GetProcessCPU(pid_t pid) {
++TimeDelta ProcessMetrics::GetCumulativeCPUUsage() {
+   struct kinfo_proc info;
+-  size_t length;
+-  int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, pid,
+-                sizeof(struct kinfo_proc), 0 };
++  size_t length = sizeof(struct kinfo_proc);
++  struct timeval tv;
+ 
+-  if (sysctl(mib, std::size(mib), NULL, &length, NULL, 0) < 0)
+-    return -1;
++  int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, process_,
++                sizeof(struct kinfo_proc), 1 };
+ 
+-  mib[5] = (length / sizeof(struct kinfo_proc));
+-
+   if (sysctl(mib, std::size(mib), &info, &length, NULL, 0) < 0)
+-    return 0;
++    return TimeDelta();
+ 
+-  return info.p_pctcpu;
+-}
++  tv.tv_sec = info.p_rtime_sec;
++  tv.tv_usec = info.p_rtime_usec;
+ 
+-double ProcessMetrics::GetPlatformIndependentCPUUsage() {
+-  TimeTicks time = TimeTicks::Now();
+-
+-  if (last_cpu_time_.is_zero()) {
+-    // First call, just set the last values.
+-    last_cpu_time_ = time;
+-    return 0;
+-  }
+-
+-  int cpu = GetProcessCPU(process_);
+-
+-  last_cpu_time_ = time;
+-  double percentage = static_cast<double>((cpu * 100.0) / FSCALE);
+-
+-  return percentage;
++  return Microseconds(TimeValToMicroseconds(tv));
+ }
+ 
+-TimeDelta ProcessMetrics::GetCumulativeCPUUsage() {
+-  NOTREACHED();
+-  return TimeDelta();
+-}
+-
+-ProcessMetrics::ProcessMetrics(ProcessHandle process)
+-    : process_(process),
+-      last_cpu_(0) {}
+-
+ size_t GetSystemCommitCharge() {
+   int mib[] = { CTL_VM, VM_METER };
+   int pagesize;
+@@ -84,6 +67,129 @@ size_t GetSystemCommitCharge() {
+   pagesize = getpagesize();
+ 
+   return mem_total - (mem_free*pagesize) - (mem_inactive*pagesize);
++}
++
++int ProcessMetrics::GetOpenFdCount() const {
++  struct kinfo_file *files;
++  kvm_t *kd = NULL;
++  int total_count = 0;
++  char errbuf[_POSIX2_LINE_MAX];
++
++  if ((kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf)) == NULL)
++    goto out;
++  
++  if ((files = kvm_getfiles(kd, KERN_FILE_BYPID, process_,  
++        sizeof(struct kinfo_file), &total_count)) == NULL) {
++	  total_count = 0;
++	  goto out;
++  }
++
++  kvm_close(kd);
++
++out:
++  return total_count;
++}
++
++int ProcessMetrics::GetOpenFdSoftLimit() const {
++  return GetMaxFds();
++}
++
++uint64_t ProcessMetrics::GetVmSwapBytes() const {
++  NOTIMPLEMENTED();
++  return 0;
++}
++
++bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo) {
++  NOTIMPLEMENTED_LOG_ONCE();
++  return false;
++}
++
++SystemDiskInfo::SystemDiskInfo() {
++  reads = 0;
++  reads_merged = 0;
++  sectors_read = 0;
++  read_time = 0;
++  writes = 0;
++  writes_merged = 0;
++  sectors_written = 0;
++  write_time = 0;
++  io = 0;
++  io_time = 0;
++  weighted_io_time = 0;
++}
++     
++SystemDiskInfo::SystemDiskInfo(const SystemDiskInfo& other) = default;
++      
++bool GetSystemDiskInfo(SystemDiskInfo* diskinfo) {
++  NOTIMPLEMENTED();
++  return false;
++}
++
++bool GetVmStatInfo(VmStatInfo* vmstat) {
++  NOTIMPLEMENTED();
++  return false;
++}
++
++int ProcessMetrics::GetIdleWakeupsPerSecond() {
++  NOTIMPLEMENTED();
++  return 0;
++}
++
++Value SystemMemoryInfoKB::ToValue() const {
++  Value res(Value::Type::DICTIONARY);
++  res.SetIntKey("total", total);
++  res.SetIntKey("free", free);
++  res.SetIntKey("available", available);
++  res.SetIntKey("buffers", buffers);
++  res.SetIntKey("cached", cached);
++  res.SetIntKey("active_anon", active_anon);
++  res.SetIntKey("inactive_anon", inactive_anon);
++  res.SetIntKey("active_file", active_file);
++  res.SetIntKey("inactive_file", inactive_file);
++  res.SetIntKey("swap_total", swap_total);
++  res.SetIntKey("swap_free", swap_free);
++  res.SetIntKey("swap_used", swap_total - swap_free);
++  res.SetIntKey("dirty", dirty);
++  res.SetIntKey("reclaimable", reclaimable);
++
++  NOTIMPLEMENTED();
++
++  return res;
++}
++
++Value VmStatInfo::ToValue() const {   
++  Value res(Value::Type::DICTIONARY);
++  res.SetIntKey("pswpin", pswpin);
++  res.SetIntKey("pswpout", pswpout);
++  res.SetIntKey("pgmajfault", pgmajfault);
++
++  NOTIMPLEMENTED();
++
++  return res;
++}
++
++SystemDiskInfo& SystemDiskInfo::operator=(const SystemDiskInfo&) = default;
++
++Value SystemDiskInfo::ToValue() const {
++  Value res(Value::Type::DICTIONARY);
++
++  // Write out uint64_t variables as doubles.
++  // Note: this may discard some precision, but for JS there's no other option.
++  res.SetDoubleKey("reads", static_cast<double>(reads));
++  res.SetDoubleKey("reads_merged", static_cast<double>(reads_merged));
++  res.SetDoubleKey("sectors_read", static_cast<double>(sectors_read));
++  res.SetDoubleKey("read_time", static_cast<double>(read_time));
++  res.SetDoubleKey("writes", static_cast<double>(writes));
++  res.SetDoubleKey("writes_merged", static_cast<double>(writes_merged));
++  res.SetDoubleKey("sectors_written", static_cast<double>(sectors_written));
++  res.SetDoubleKey("write_time", static_cast<double>(write_time));
++  res.SetDoubleKey("io", static_cast<double>(io));
++  res.SetDoubleKey("io_time", static_cast<double>(io_time));
++  res.SetDoubleKey("weighted_io_time", static_cast<double>(weighted_io_time));
++
++  NOTIMPLEMENTED();
++
++  return res;
+ }
+ 
+ }  // namespace base

www/ungoogled-chromium/files/patch-base_process_process__metrics__posix.cc

@@ -0,0 +1,20 @@
+--- base/process/process_metrics_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_metrics_posix.cc
+@@ -20,6 +20,8 @@
+ 
+ #if BUILDFLAG(IS_APPLE)
+ #include <malloc/malloc.h>
++#elif BUILDFLAG(IS_OPENBSD)
++#include <stdlib.h>
+ #else
+ #include <malloc.h>
+ #endif
+@@ -135,7 +137,7 @@ size_t ProcessMetrics::GetMallocUsage() {
+   return stats.size_in_use;
+ #elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
+   return GetMallocUsageMallinfo();
+-#elif BUILDFLAG(IS_FUCHSIA)
++#elif BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_BSD)
+   // TODO(fuchsia): Not currently exposed. https://crbug.com/735087.
+   return 0;
+ #endif

www/ungoogled-chromium/files/patch-base_process_process__metrics__unittest.cc

@@ -0,0 +1,20 @@
+--- base/process/process_metrics_unittest.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_metrics_unittest.cc
+@@ -44,7 +44,7 @@ namespace debug {
+ 
+ #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) ||      \
+     BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_WIN) || \
+-    BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_FUCHSIA)
++    BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_BSD)
+ 
+ namespace {
+ 
+@@ -347,7 +347,7 @@ TEST_F(SystemMetricsTest, ParseVmstat) {
+ 
+ #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) ||      \
+     BUILDFLAG(IS_CHROMEOS_LACROS) || BUILDFLAG(IS_WIN) || \
+-    BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_FUCHSIA)
++    BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_BSD)
+ 
+ // Test that ProcessMetrics::GetPlatformIndependentCPUUsage() doesn't return
+ // negative values when the number of threads running on the process decreases

www/ungoogled-chromium/files/patch-base_process_process__posix.cc

@@ -0,0 +1,93 @@
+--- base/process/process_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_posix.cc
+@@ -25,10 +25,15 @@
+ #include "build/build_config.h"
+ #include "third_party/abseil-cpp/absl/types/optional.h"
+ 
+-#if BUILDFLAG(IS_MAC)
++#if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_BSD)
+ #include <sys/event.h>
+ #endif
+ 
++#if defined(OS_BSD)
++#include <sys/types.h>
++#include <sys/sysctl.h> 
++#endif
++
+ #if BUILDFLAG(CLANG_PROFILING)
+ #include "base/test/clang_profiling.h"
+ #endif
+@@ -95,7 +100,7 @@ bool WaitpidWithTimeout(base::ProcessHandle handle,
+   return ret_pid > 0;
+ }
+ 
+-#if BUILDFLAG(IS_MAC)
++#if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_BSD)
+ // Using kqueue on Mac so that we can wait on non-child processes.
+ // We can't use kqueues on child processes because we need to reap
+ // our own children using wait.
+@@ -200,7 +205,7 @@ bool WaitForExitWithTimeoutImpl(base::ProcessHandle ha
+   const bool exited = (parent_pid < 0);
+ 
+   if (!exited && parent_pid != our_pid) {
+-#if BUILDFLAG(IS_MAC)
++#if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_BSD)
+     // On Mac we can wait on non child processes.
+     return WaitForSingleNonChildProcess(handle, timeout);
+ #else
+@@ -392,7 +397,55 @@ void Process::Exited(int exit_code) const {
+ 
+ int Process::GetPriority() const {
+   DCHECK(IsValid());
++// avoid pledge(2) violation
++#if defined(OS_BSD)
++  return 0;
++#else
+   return getpriority(PRIO_PROCESS, static_cast<id_t>(process_));
++#endif
++}
++
++Time Process::CreationTime() const {
++// avoid ps pledge in the network process
++#if !defined(OS_BSD)
++  int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid(),
++               sizeof(struct kinfo_proc), 0 };
++  struct kinfo_proc *info = nullptr;
++  size_t info_size;
++#endif
++  Time ct = Time();
++
++#if !defined(OS_BSD)
++  if (sysctl(mib, std::size(mib), NULL, &info_size, NULL, 0) < 0)
++    goto out;
++
++  mib[5] = (info_size / sizeof(struct kinfo_proc));
++  if ((info = reinterpret_cast<kinfo_proc*>(malloc(info_size))) == NULL)
++    goto out;
++
++  if (sysctl(mib, std::size(mib), info, &info_size, NULL, 0) < 0)
++    goto out;
++
++  ct = Time::FromTimeT(info->p_ustart_sec);
++
++out:
++  if (info)
++    free(info);
++#endif
++  return ct;
++}
++
++bool Process::IsProcessBackgrounded() const {
++  return false;
++}
++ 
++bool Process::SetProcessBackgrounded(bool value) {
++  return false;
++}
++ 
++// static
++bool Process::CanBackgroundProcesses() {
++  return false;
+ }
+ 
+ }  // namespace base

www/ungoogled-chromium/files/patch-base_process_process__unittest.cc

@@ -0,0 +1,11 @@
+--- base/process/process_unittest.cc.orig	2022-10-01 07:40:07 UTC
++++ base/process/process_unittest.cc
+@@ -193,7 +193,7 @@ TEST_F(ProcessTest, CreationTimeOtherProcess) {
+   // was spawned and a time recorded after it was spawned. However, since the
+   // base::Time and process creation clocks don't match, tolerate some error.
+   constexpr base::TimeDelta kTolerance =
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+       // On Linux, process creation time is relative to boot time which has a
+       // 1-second resolution. Tolerate 1 second for the imprecise boot time and
+       // 100 ms for the imprecise clock.

www/ungoogled-chromium/files/patch-base_profiler_module__cache.cc

@@ -0,0 +1,11 @@
+--- base/profiler/module_cache.cc.orig	2022-10-01 07:40:07 UTC
++++ base/profiler/module_cache.cc
+@@ -34,7 +34,7 @@ struct ModuleAddressCompare {
+ 
+ std::string TransformModuleIDToBreakpadFormat(StringPiece module_id) {
+   std::string mangled_id(module_id);
+-#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+   // Linux ELF module IDs are 160bit integers, which we need to mangle
+   // down to 128bit integers to match the id that Breakpad outputs.
+   // Example on version '66.0.3359.170' x64:

www/ungoogled-chromium/files/patch-base_profiler_stack__sampling__profiler__test__util.cc

@@ -0,0 +1,11 @@
+--- base/profiler/stack_sampling_profiler_test_util.cc.orig	2022-10-01 07:40:07 UTC
++++ base/profiler/stack_sampling_profiler_test_util.cc
+@@ -39,7 +39,7 @@
+ // Fortunately, it provides _alloca, which functions identically.
+ #include <malloc.h>
+ #define alloca _alloca
+-#else
++#elif !BUILDFLAG(IS_BSD)
+ #include <alloca.h>
+ #endif
+ 

www/ungoogled-chromium/files/patch-base_profiler_stack__sampling__profiler__unittest.cc

@@ -0,0 +1,11 @@
+--- base/profiler/stack_sampling_profiler_unittest.cc.orig	2022-10-01 07:40:07 UTC
++++ base/profiler/stack_sampling_profiler_unittest.cc
+@@ -41,7 +41,7 @@
+ #include <intrin.h>
+ #include <malloc.h>
+ #include <windows.h>
+-#else
++#elif !BUILDFLAG(IS_BSD)
+ #include <alloca.h>
+ #endif
+ 

www/ungoogled-chromium/files/patch-base_rand__util.h

@@ -0,0 +1,11 @@
+--- base/rand_util.h.orig	2022-10-01 07:40:07 UTC
++++ base/rand_util.h
+@@ -80,7 +80,7 @@ void RandomShuffle(Itr first, Itr last) {
+   std::shuffle(first, last, RandomBitGenerator());
+ }
+ 
+-#if BUILDFLAG(IS_POSIX)
++#if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_BSD)
+ BASE_EXPORT int GetUrandomFD();
+ #endif
+ 

www/ungoogled-chromium/files/patch-base_rand__util__posix.cc

@@ -0,0 +1,57 @@
+--- base/rand_util_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/rand_util_posix.cc
+@@ -22,7 +22,7 @@
+ #include "base/time/time.h"
+ #include "build/build_config.h"
+ 
+-#if (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)) && !BUILDFLAG(IS_NACL)
++#if (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)) && !BUILDFLAG(IS_NACL) && !BUILDFLAG(IS_BSD)
+ #include "third_party/lss/linux_syscall_support.h"
+ #elif BUILDFLAG(IS_MAC)
+ // TODO(crbug.com/995996): Waiting for this header to appear in the iOS SDK.
+@@ -39,6 +39,7 @@ static constexpr int kOpenFlags = O_RDONLY;
+ static constexpr int kOpenFlags = O_RDONLY | O_CLOEXEC;
+ #endif
+ 
++#if !BUILDFLAG(IS_BSD)
+ // We keep the file descriptor for /dev/urandom around so we don't need to
+ // reopen it (which is expensive), and since we may not even be able to reopen
+ // it if we are later put in a sandbox. This class wraps the file descriptor so
+@@ -56,10 +57,11 @@ class URandomFd {
+  private:
+   const int fd_;
+ };
++#endif
+ 
+ #if (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || \
+      BUILDFLAG(IS_ANDROID)) &&                        \
+-    !BUILDFLAG(IS_NACL)
++    !BUILDFLAG(IS_NACL) && !BUILDFLAG(IS_BSD)
+ // TODO(pasko): Unify reading kernel version numbers in:
+ // mojo/core/channel_linux.cc
+ // chrome/browser/android/seccomp_support_detector.cc
+@@ -144,6 +146,7 @@ void ConfigureRandBytesFieldTrial() {
+ // (https://chromium-review.9oo91esource.qjz9zk/c/chromium/src/+/1545096) and land
+ // it or some form of it.
+ void RandBytes(void* output, size_t output_length) {
++#if !BUILDFLAG(IS_BSD)
+ #if (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || \
+      BUILDFLAG(IS_ANDROID)) &&                        \
+     !BUILDFLAG(IS_NACL)
+@@ -172,11 +175,16 @@ void RandBytes(void* output, size_t output_length) {
+   const bool success =
+       ReadFromFD(urandom_fd, static_cast<char*>(output), output_length);
+   CHECK(success);
++#else
++  arc4random_buf(static_cast<char*>(output), output_length);
++#endif
+ }
+ 
++#if !BUILDFLAG(IS_BSD)
+ int GetUrandomFD() {
+   static NoDestructor<URandomFd> urandom_fd;
+   return urandom_fd->fd();
+ }
++#endif
+ 
+ }  // namespace base

www/ungoogled-chromium/files/patch-base_strings_safe__sprintf__unittest.cc

@@ -0,0 +1,18 @@
+--- base/strings/safe_sprintf_unittest.cc.orig	2022-10-01 07:40:07 UTC
++++ base/strings/safe_sprintf_unittest.cc
+@@ -732,6 +732,7 @@ TEST(SafeSPrintfTest, EmbeddedNul) {
+ #endif
+ }
+ 
++#if !BUILDFLAG(IS_BSD)
+ TEST(SafeSPrintfTest, EmitNULL) {
+   char buf[40];
+ #if defined(__GNUC__)
+@@ -748,6 +749,7 @@ TEST(SafeSPrintfTest, EmitNULL) {
+ #pragma GCC diagnostic pop
+ #endif
+ }
++#endif
+ 
+ TEST(SafeSPrintfTest, PointerSize) {
+   // The internal data representation is a 64bit value, independent of the

www/ungoogled-chromium/files/patch-base_synchronization_lock__impl.h

@@ -0,0 +1,23 @@
+--- base/synchronization/lock_impl.h.orig	2022-10-01 07:40:07 UTC
++++ base/synchronization/lock_impl.h
+@@ -107,6 +107,10 @@ void LockImpl::Unlock() {
+ }
+ 
+ #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
++#if BUILDFLAG(IS_FREEBSD)
++#pragma GCC diagnostic push
++#pragma GCC diagnostic ignored "-Wthread-safety-analysis"
++#endif
+ 
+ #if DCHECK_IS_ON()
+ BASE_EXPORT void dcheck_trylock_result(int rv);
+@@ -127,6 +131,9 @@ void LockImpl::Unlock() {
+   dcheck_unlock_result(rv);
+ #endif
+ }
++#if BUILDFLAG(IS_FREEBSD)
++#pragma GCC diagnostic pop
++#endif
+ #endif
+ 
+ // This is an implementation used for AutoLock templated on the lock type.

www/ungoogled-chromium/files/patch-base_syslog__logging.cc

@@ -0,0 +1,20 @@
+--- base/syslog_logging.cc.orig	2022-10-01 07:40:07 UTC
++++ base/syslog_logging.cc
+@@ -15,7 +15,7 @@
+ #include "base/strings/string_util.h"
+ #include "base/win/scoped_handle.h"
+ #include "base/win/win_util.h"
+-#elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ // <syslog.h> defines LOG_INFO, LOG_WARNING macros that could conflict with
+ // base::LOG_INFO, base::LOG_WARNING.
+ #include <syslog.h>
+@@ -147,7 +147,7 @@ EventLogMessage::~EventLogMessage() {
+ 
+   if (user_sid != nullptr)
+     ::LocalFree(user_sid);
+-#elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+   const char kEventSource[] = "chrome";
+   openlog(kEventSource, LOG_NOWAIT | LOG_PID, LOG_USER);
+   // We can't use the defined names for the logging severity from syslog.h

www/ungoogled-chromium/files/patch-base_system_sys__info.cc

@@ -0,0 +1,11 @@
+--- base/system/sys_info.cc.orig	2022-10-01 07:40:07 UTC
++++ base/system/sys_info.cc
+@@ -101,7 +101,7 @@ std::string SysInfo::HardwareModelName() {
+ #endif
+ 
+ void SysInfo::GetHardwareInfo(base::OnceCallback<void(HardwareInfo)> callback) {
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_FUCHSIA)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_BSD)
+   constexpr base::TaskTraits kTraits = {base::MayBlock()};
+ #else
+   constexpr base::TaskTraits kTraits = {};

www/ungoogled-chromium/files/patch-base_system_sys__info.h

@@ -0,0 +1,20 @@
+--- base/system/sys_info.h.orig	2022-10-01 07:40:07 UTC
++++ base/system/sys_info.h
+@@ -211,6 +211,8 @@ class BASE_EXPORT SysInfo {
+   // On Desktop this returns true when memory <= 2GB.
+   static bool IsLowEndDevice();
+ 
++  static uint64_t MaxSharedMemorySize();
++
+  private:
+   FRIEND_TEST_ALL_PREFIXES(SysInfoTest, AmountOfAvailablePhysicalMemory);
+   FRIEND_TEST_ALL_PREFIXES(debug::SystemMetricsTest, ParseMeminfo);
+@@ -221,7 +223,7 @@ class BASE_EXPORT SysInfo {
+   static HardwareInfo GetHardwareInfoSync();
+ 
+ #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID) || \
+-    BUILDFLAG(IS_AIX)
++    BUILDFLAG(IS_AIX) || BUILDFLAG(IS_BSD)
+   static uint64_t AmountOfAvailablePhysicalMemory(
+       const SystemMemoryInfoKB& meminfo);
+ #endif

www/ungoogled-chromium/files/patch-base_system_sys__info__freebsd.cc

@@ -0,0 +1,115 @@
+--- base/system/sys_info_freebsd.cc.orig	2022-10-01 07:40:07 UTC
++++ base/system/sys_info_freebsd.cc
+@@ -9,30 +9,106 @@
+ #include <sys/sysctl.h>
+ 
+ #include "base/notreached.h"
++#include "base/process/process_metrics.h"
++#include "base/strings/string_util.h"
+ 
+ namespace base {
+ 
+-int64_t SysInfo::AmountOfPhysicalMemoryImpl() {
+-  int pages, page_size;
++int SysInfo::NumberOfProcessors() {
++  int mib[] = {CTL_HW, HW_NCPU};
++  int ncpu;
++  size_t size = sizeof(ncpu);
++  if (sysctl(mib, std::size(mib), &ncpu, &size, NULL, 0) < 0) {
++    NOTREACHED();
++    return 1;
++  }
++  return ncpu;
++}
++
++uint64_t SysInfo::AmountOfPhysicalMemoryImpl() {
++  int pages, page_size, r = 0;
+   size_t size = sizeof(pages);
+-  sysctlbyname("vm.stats.vm.v_page_count", &pages, &size, NULL, 0);
+-  sysctlbyname("vm.stats.vm.v_page_size", &page_size, &size, NULL, 0);
+-  if (pages == -1 || page_size == -1) {
++
++  if (r == 0)
++    r = sysctlbyname("vm.stats.vm.v_page_count", &pages, &size, NULL, 0);
++  if (r == 0)
++    r = sysctlbyname("vm.stats.vm.v_page_size", &page_size, &size, NULL, 0);
++
++  if (r == -1) {
+     NOTREACHED();
+     return 0;
+   }
+-  return static_cast<int64_t>(pages) * page_size;
++
++  return static_cast<uint64_t>(pages) * page_size;
+ }
+ 
++uint64_t SysInfo::AmountOfAvailablePhysicalMemoryImpl() {
++  int page_size, r = 0;
++  unsigned int pgfree, pginact, pgcache;
++  size_t size = sizeof(page_size);
++  size_t szpg = sizeof(pgfree);
++
++  if (r == 0)
++    r = sysctlbyname("vm.stats.vm.v_page_size", &page_size, &size, NULL, 0);
++  if (r == 0)
++    r = sysctlbyname("vm.stats.vm.v_free_count", &pgfree, &szpg, NULL, 0);
++  if (r == 0)
++    r = sysctlbyname("vm.stats.vm.v_inactive_count", &pginact, &szpg, NULL, 0);
++  if (r == 0)
++    r = sysctlbyname("vm.stats.vm.v_cache_count", &pgcache, &szpg, NULL, 0);
++
++  if (r == -1) {
++    NOTREACHED();
++    return 0;
++  }
++
++  return static_cast<uint64_t>((pgfree + pginact + pgcache) * page_size);
++}
++
+ // static
++uint64_t SysInfo::AmountOfAvailablePhysicalMemory(const SystemMemoryInfoKB& info) {
++  uint64_t res_kb = info.available != 0
++                       ? info.available - info.active_file
++                       : info.free + info.reclaimable + info.inactive_file;
++  return res_kb * 1024;
++}
++
++// static
++std::string SysInfo::CPUModelName() {
++  int mib[] = { CTL_HW, HW_MODEL };
++  char name[256];
++  size_t size = std::size(name);
++
++  if (sysctl(mib, std::size(mib), &name, &size, NULL, 0) == 0) {
++    return name;
++  }
++
++  return std::string();
++}
++
++// static
+ uint64_t SysInfo::MaxSharedMemorySize() {
+   size_t limit;
+   size_t size = sizeof(limit);
++
+   if (sysctlbyname("kern.ipc.shmmax", &limit, &size, NULL, 0) < 0) {
+     NOTREACHED();
+     return 0;
+   }
++
+   return static_cast<uint64_t>(limit);
++}
++
++SysInfo::HardwareInfo SysInfo::GetHardwareInfoSync() {
++  HardwareInfo info;
++
++  info.manufacturer = "FreeBSD";
++  info.model = HardwareModelName();
++
++  DCHECK(IsStringUTF8(info.manufacturer));
++  DCHECK(IsStringUTF8(info.model));
++
++  return info;
+ }
+ 
+ }  // namespace base

www/ungoogled-chromium/files/patch-base_system_sys__info__openbsd.cc

@@ -0,0 +1,94 @@
+--- base/system/sys_info_openbsd.cc.orig	2022-10-01 07:40:07 UTC
++++ base/system/sys_info_openbsd.cc
+@@ -11,6 +11,7 @@
+ #include <sys/sysctl.h>
+ 
+ #include "base/notreached.h"
++#include "base/strings/string_util.h"
+ 
+ namespace {
+ 
+@@ -26,9 +27,15 @@ uint64_t AmountOfMemory(int pages_name) {
+ 
+ namespace base {
+ 
++// pledge(2)
++int64_t aofpmem = 0;
++int64_t aofapmem = 0;
++int64_t shmmax = 0;
++char cpumodel[256];
++
+ // static
+ int SysInfo::NumberOfProcessors() {
+-  int mib[] = {CTL_HW, HW_NCPU};
++  int mib[] = {CTL_HW, HW_NCPUONLINE};
+   int ncpu;
+   size_t size = sizeof(ncpu);
+   if (sysctl(mib, std::size(mib), &ncpu, &size, NULL, 0) < 0) {
+@@ -40,10 +47,26 @@ int SysInfo::NumberOfProcessors() {
+ 
+ // static
+ uint64_t SysInfo::AmountOfPhysicalMemoryImpl() {
+-  return AmountOfMemory(_SC_PHYS_PAGES);
++  // pledge(2)
++  if (!aofpmem)
++    aofpmem = AmountOfMemory(_SC_PHYS_PAGES);
++  return aofpmem;
+ }
+ 
+ // static
++std::string SysInfo::CPUModelName() {
++  int mib[] = {CTL_HW, HW_MODEL};
++  size_t len = std::size(cpumodel);
++
++  if (cpumodel[0] == '\0') {
++    if (sysctl(mib, std::size(mib), cpumodel, &len, NULL, 0) < 0)
++      return std::string();
++  }
++
++  return std::string(cpumodel, len - 1);
++}
++
++// static
+ uint64_t SysInfo::AmountOfAvailablePhysicalMemoryImpl() {
+   // We should add inactive file-backed memory also but there is no such
+   // information from OpenBSD unfortunately.
+@@ -55,23 +78,28 @@ uint64_t SysInfo::MaxSharedMemorySize() {
+   int mib[] = {CTL_KERN, KERN_SHMINFO, KERN_SHMINFO_SHMMAX};
+   size_t limit;
+   size_t size = sizeof(limit);
++  // pledge(2)
++  if (shmmax)
++    goto out;
+   if (sysctl(mib, std::size(mib), &limit, &size, NULL, 0) < 0) {
+     NOTREACHED();
+     return 0;
+   }
+-  return static_cast<uint64_t>(limit);
++  shmmax = static_cast<uint64_t>(limit);
++out:
++  return shmmax;
+ }
+ 
+ // static
+-std::string SysInfo::CPUModelName() {
+-  int mib[] = {CTL_HW, HW_MODEL};
+-  char name[256];
+-  size_t len = std::size(name);
+-  if (sysctl(mib, std::size(mib), name, &len, NULL, 0) < 0) {
+-    NOTREACHED();
+-    return std::string();
+-  }
+-  return name;
++SysInfo::HardwareInfo SysInfo::GetHardwareInfoSync() {
++  HardwareInfo info;
++  // Set the manufacturer to "OpenBSD" and the model to
++  // an empty string.
++  info.manufacturer = "OpenBSD";
++  info.model = HardwareModelName();
++  DCHECK(IsStringUTF8(info.manufacturer));
++  DCHECK(IsStringUTF8(info.model));
++  return info;
+ }
+ 
+ }  // namespace base

www/ungoogled-chromium/files/patch-base_system_sys__info__posix.cc

@@ -0,0 +1,43 @@
+--- base/system/sys_info_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/system/sys_info_posix.cc
+@@ -37,7 +37,7 @@
+ 
+ namespace {
+ 
+-#if !BUILDFLAG(IS_OPENBSD)
++#if !BUILDFLAG(IS_BSD)
+ int NumberOfProcessors() {
+   // sysconf returns the number of "logical" (not "physical") processors on both
+   // Mac and Linux.  So we get the number of max available "logical" processors.
+@@ -77,7 +77,7 @@ int NumberOfProcessors() {
+ 
+ base::LazyInstance<base::internal::LazySysInfoValue<int, NumberOfProcessors>>::
+     Leaky g_lazy_number_of_processors = LAZY_INSTANCE_INITIALIZER;
+-#endif  // !BUILDFLAG(IS_OPENBSD)
++#endif  // !BUILDFLAG(IS_BSD)
+ 
+ uint64_t AmountOfVirtualMemory() {
+   struct rlimit limit;
+@@ -144,11 +144,11 @@ bool GetDiskSpaceInfo(const base::FilePath& path,
+ 
+ namespace base {
+ 
+-#if !BUILDFLAG(IS_OPENBSD)
++#if !BUILDFLAG(IS_BSD)
+ int SysInfo::NumberOfProcessors() {
+   return g_lazy_number_of_processors.Get().value();
+ }
+-#endif  // !BUILDFLAG(IS_OPENBSD)
++#endif  // !BUILDFLAG(IS_BSD)
+ 
+ // static
+ uint64_t SysInfo::AmountOfVirtualMemory() {
+@@ -238,6 +238,8 @@ std::string SysInfo::OperatingSystemArchitecture() {
+     arch = "x86";
+   } else if (arch == "amd64") {
+     arch = "x86_64";
++  } else if (arch == "arm64") {
++    arch = "aarch64";
+   } else if (std::string(info.sysname) == "AIX") {
+     arch = "ppc64";
+   }

www/ungoogled-chromium/files/patch-base_system_sys__info__unittest.cc

@@ -0,0 +1,20 @@
+--- base/system/sys_info_unittest.cc.orig	2022-10-01 07:40:07 UTC
++++ base/system/sys_info_unittest.cc
+@@ -234,12 +234,16 @@ TEST_F(SysInfoTest, GetHardwareInfo) {
+   EXPECT_TRUE(IsStringUTF8(hardware_info->model));
+   bool empty_result_expected =
+ #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_WIN) || \
+-    BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_FUCHSIA)
++    BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_FUCHSIA) || \
++    BUILDFLAG(IS_BSD)
+       false;
+ #else
+       true;
+ #endif
+   EXPECT_EQ(hardware_info->manufacturer.empty(), empty_result_expected);
++#if BUILDFLAG(IS_BSD)
++  empty_result_expected = true;
++#endif
+   EXPECT_EQ(hardware_info->model.empty(), empty_result_expected);
+ }
+ 

www/ungoogled-chromium/files/patch-base_task_thread__pool_environment__config__unittest.cc

@@ -0,0 +1,11 @@
+--- base/task/thread_pool/environment_config_unittest.cc.orig	2022-10-01 07:40:07 UTC
++++ base/task/thread_pool/environment_config_unittest.cc
+@@ -15,7 +15,7 @@ TEST(ThreadPoolEnvironmentConfig, CanUseBackgroundPrio
+ #if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_APPLE)
+   EXPECT_TRUE(CanUseBackgroundThreadTypeForWorkerThread());
+ #elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_FUCHSIA) || \
+-    BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_NACL)
++    BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_NACL) || BUILDFLAG(IS_BSD)
+   EXPECT_FALSE(CanUseBackgroundThreadTypeForWorkerThread());
+ #else
+ #error Platform doesn't match any block

www/ungoogled-chromium/files/patch-base_test_launcher_test__launcher.cc

@@ -0,0 +1,10 @@
+--- base/test/launcher/test_launcher.cc.orig	2022-10-01 07:40:07 UTC
++++ base/test/launcher/test_launcher.cc
+@@ -65,6 +65,7 @@
+ #include "third_party/libxml/chromium/libxml_utils.h"
+ 
+ #if BUILDFLAG(IS_POSIX)
++#include <signal.h>
+ #include <fcntl.h>
+ 
+ #include "base/files/file_descriptor_watcher_posix.h"

www/ungoogled-chromium/files/patch-base_test_test__file__util__linux.cc

@@ -0,0 +1,13 @@
+--- base/test/test_file_util_linux.cc.orig	2022-10-01 07:40:07 UTC
++++ base/test/test_file_util_linux.cc
+@@ -54,8 +54,10 @@ bool EvictFileFromSystemCache(const FilePath& file) {
+     return false;
+   if (fdatasync(fd.get()) != 0)
+     return false;
++#if !defined(OS_BSD)
+   if (posix_fadvise(fd.get(), 0, 0, POSIX_FADV_DONTNEED) != 0)
+     return false;
++#endif
+   return true;
+ }
+ 

www/ungoogled-chromium/files/patch-base_test_test__file__util__posix.cc

@@ -0,0 +1,11 @@
+--- base/test/test_file_util_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/test/test_file_util_posix.cc
+@@ -88,7 +88,7 @@ void SyncPageCacheToDisk() {
+ }
+ 
+ #if !BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_CHROMEOS) && !BUILDFLAG(IS_APPLE) && \
+-    !BUILDFLAG(IS_ANDROID)
++    !BUILDFLAG(IS_ANDROID) && !BUILDFLAG(IS_BSD)
+ bool EvictFileFromSystemCache(const FilePath& file) {
+   // There doesn't seem to be a POSIX way to cool the disk cache.
+   NOTIMPLEMENTED();

www/ungoogled-chromium/files/patch-base_third__party_symbolize_symbolize.cc

@@ -0,0 +1,11 @@
+--- base/third_party/symbolize/symbolize.cc.orig	2022-10-01 07:40:07 UTC
++++ base/third_party/symbolize/symbolize.cc
+@@ -114,7 +114,7 @@ _END_GOOGLE_NAMESPACE_
+ #if defined(HAVE_DLFCN_H)
+ #include <dlfcn.h>
+ #endif
+-#if BUILDFLAG(IS_OPENBSD)
++#if defined(__OpenBSD__)
+ #include <sys/exec_elf.h>
+ #else
+ #include <elf.h>

www/ungoogled-chromium/files/patch-base_threading_platform__thread.h

@@ -0,0 +1,11 @@
+--- base/threading/platform_thread.h.orig	2022-10-01 07:40:07 UTC
++++ base/threading/platform_thread.h
+@@ -253,7 +253,7 @@ class BASE_EXPORT PlatformThread {
+   // Returns a realtime period provided by `delegate`.
+   static TimeDelta GetRealtimePeriod(Delegate* delegate);
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+   // Toggles a specific thread's type at runtime. This can be used to
+   // change the priority of a thread in a different process and will fail
+   // if the calling process does not have proper permissions. The

www/ungoogled-chromium/files/patch-base_threading_platform__thread__linux.cc

@@ -0,0 +1,77 @@
+--- base/threading/platform_thread_linux.cc.orig	2022-10-01 07:40:07 UTC
++++ base/threading/platform_thread_linux.cc
+@@ -29,7 +29,9 @@
+ 
+ #if !BUILDFLAG(IS_NACL) && !BUILDFLAG(IS_AIX)
+ #include <pthread.h>
++#if !BUILDFLAG(IS_BSD)
+ #include <sys/prctl.h>
++#endif
+ #include <sys/resource.h>
+ #include <sys/time.h>
+ #include <sys/types.h>
+@@ -132,7 +134,7 @@ long sched_setattr(pid_t pid,
+ #endif  // !BUILDFLAG(IS_NACL) && !BUILDFLAG(IS_AIX)
+ #endif  // BUILDFLAG(IS_CHROMEOS)
+ 
+-#if !BUILDFLAG(IS_NACL)
++#if !BUILDFLAG(IS_NACL) && !BUILDFLAG(IS_BSD)
+ const FilePath::CharType kCgroupDirectory[] =
+     FILE_PATH_LITERAL("/sys/fs/cgroup");
+ 
+@@ -304,7 +306,7 @@ void SetThreadCgroupsForThreadType(PlatformThreadId th
+ namespace internal {
+ 
+ namespace {
+-#if !BUILDFLAG(IS_NACL)
++#if !BUILDFLAG(IS_NACL) && !BUILDFLAG(IS_BSD)
+ const struct sched_param kRealTimePrio = {8};
+ #endif
+ }  // namespace
+@@ -330,7 +332,7 @@ const ThreadTypeToNiceValuePair kThreadTypeToNiceValue
+ };
+ 
+ bool CanSetThreadTypeToRealtimeAudio() {
+-#if !BUILDFLAG(IS_NACL)
++#if !BUILDFLAG(IS_NACL) && !BUILDFLAG(IS_BSD)
+   // A non-zero soft-limit on RLIMIT_RTPRIO is required to be allowed to invoke
+   // pthread_setschedparam in SetCurrentThreadTypeForPlatform().
+   struct rlimit rlim;
+@@ -342,7 +344,7 @@ bool CanSetThreadTypeToRealtimeAudio() {
+ 
+ bool SetCurrentThreadTypeForPlatform(ThreadType thread_type,
+                                      MessagePumpType pump_type_hint) {
+-#if !BUILDFLAG(IS_NACL)
++#if !BUILDFLAG(IS_NACL) && !BUILDFLAG(IS_BSD)
+   // For legacy schedtune interface
+   SetThreadCgroupsForThreadType(PlatformThread::CurrentId(), thread_type);
+ 
+@@ -361,7 +363,7 @@ bool SetCurrentThreadTypeForPlatform(ThreadType thread
+ 
+ absl::optional<ThreadPriorityForTest>
+ GetCurrentThreadPriorityForPlatformForTest() {
+-#if !BUILDFLAG(IS_NACL)
++#if !BUILDFLAG(IS_NACL) && !BUILDFLAG(IS_BSD)
+   int maybe_sched_rr = 0;
+   struct sched_param maybe_realtime_prio = {0};
+   if (pthread_getschedparam(pthread_self(), &maybe_sched_rr,
+@@ -380,7 +382,7 @@ GetCurrentThreadPriorityForPlatformForTest() {
+ void PlatformThread::SetName(const std::string& name) {
+   ThreadIdNameManager::GetInstance()->SetName(name);
+ 
+-#if !BUILDFLAG(IS_NACL) && !BUILDFLAG(IS_AIX)
++#if !BUILDFLAG(IS_NACL) && !BUILDFLAG(IS_AIX) && !BUILDFLAG(IS_BSD)
+   // On linux we can get the thread names to show up in the debugger by setting
+   // the process name for the LWP.  We don't want to do this for the main
+   // thread because that would rename the process, causing tools like killall
+@@ -410,8 +412,10 @@ void PlatformThread::SetThreadType(ProcessId process_i
+   // priority.
+   CHECK_NE(thread_id, process_id);
+ 
++#if !BUILDFLAG(IS_BSD)
+   // For legacy schedtune interface
+   SetThreadCgroupsForThreadType(thread_id, thread_type);
++#endif
+ 
+ #if BUILDFLAG(IS_CHROMEOS)
+   // For upstream uclamp interface. We try both legacy (schedtune, as done

www/ungoogled-chromium/files/patch-base_threading_platform__thread__posix.cc

@@ -0,0 +1,21 @@
+--- base/threading/platform_thread_posix.cc.orig	2022-10-01 07:40:07 UTC
++++ base/threading/platform_thread_posix.cc
+@@ -76,7 +76,7 @@ void* ThreadFunc(void* params) {
+     if (!thread_params->joinable)
+       base::DisallowSingleton();
+ 
+-#if !BUILDFLAG(IS_NACL)
++#if !BUILDFLAG(IS_NACL) && !BUILDFLAG(IS_BSD)
+ #if BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
+     partition_alloc::internal::PCScan::NotifyThreadCreated(
+         partition_alloc::internal::GetStackPointer());
+@@ -371,6 +371,9 @@ namespace internal {
+ void SetCurrentThreadTypeImpl(ThreadType thread_type,
+                               MessagePumpType pump_type_hint) {
+ #if BUILDFLAG(IS_NACL)
++  NOTIMPLEMENTED();
++// avoid pledge(2) violation
++#elif BUILDFLAG(IS_BSD)
+   NOTIMPLEMENTED();
+ #else
+   if (internal::SetCurrentThreadTypeForPlatform(thread_type, pump_type_hint))

www/ungoogled-chromium/files/patch-base_threading_platform__thread__unittest.cc

@@ -0,0 +1,47 @@
+--- base/threading/platform_thread_unittest.cc.orig	2022-10-01 07:40:07 UTC
++++ base/threading/platform_thread_unittest.cc
+@@ -31,7 +31,7 @@
+ #include "base/time/time.h"
+ #endif
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ #include <pthread.h>
+ #include <sys/syscall.h>
+ #include <sys/types.h>
+@@ -417,7 +417,7 @@ TEST(PlatformThreadTest,
+ // and hardcodes what we know. Please inform scheduler-dev@ch40m1um.qjz9zk if this
+ // proprerty changes for a given platform.
+ TEST(PlatformThreadTest, CanChangeThreadType) {
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+   // On Ubuntu, RLIMIT_NICE and RLIMIT_RTPRIO are 0 by default, so we won't be
+   // able to increase priority to any level.
+   constexpr bool kCanIncreasePriority = false;
+@@ -523,7 +523,7 @@ TEST(PlatformThreadTest, SetHugeThreadName) {
+ TEST(PlatformThreadTest, GetDefaultThreadStackSize) {
+   size_t stack_size = PlatformThread::GetDefaultThreadStackSize();
+ #if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_IOS) || BUILDFLAG(IS_FUCHSIA) || \
+-    ((BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)) &&                \
++    ((BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)) && \
+      !defined(THREAD_SANITIZER)) ||                                    \
+     (BUILDFLAG(IS_ANDROID) && !defined(ADDRESS_SANITIZER))
+   EXPECT_EQ(0u, stack_size);
+@@ -684,12 +684,16 @@ INSTANTIATE_TEST_SUITE_P(
+ 
+ #endif  // BUILDFLAG(IS_APPLE)
+ 
+-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
++#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_BSD)
+ 
+ namespace {
+ 
+ bool IsTidCacheCorrect() {
++#if BUILDFLAG(IS_BSD)
++  return PlatformThread::CurrentId() == reinterpret_cast<int64_t>(pthread_self());
++#else
+   return PlatformThread::CurrentId() == syscall(__NR_gettid);
++#endif
+ }
+ 
+ void* CheckTidCacheCorrectWrapper(void*) {

www/ungoogled-chromium/files/patch-base_trace__event_malloc__dump__provider.cc

@@ -0,0 +1,30 @@
+--- base/trace_event/malloc_dump_provider.cc.orig	2022-10-01 07:40:07 UTC
++++ base/trace_event/malloc_dump_provider.cc
+@@ -24,6 +24,8 @@
+ 
+ #if BUILDFLAG(IS_APPLE)
+ #include <malloc/malloc.h>
++#elif defined(OS_BSD)
++#include <stdlib.h>
+ #else
+ #include <malloc.h>
+ #endif
+@@ -185,7 +187,7 @@ void ReportAppleAllocStats(size_t* total_virtual_size,
+ 
+ #if (BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC) && BUILDFLAG(IS_ANDROID)) || \
+     (!BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC) && !BUILDFLAG(IS_WIN) &&    \
+-     !BUILDFLAG(IS_APPLE) && !BUILDFLAG(IS_FUCHSIA))
++     !BUILDFLAG(IS_APPLE) && !BUILDFLAG(IS_FUCHSIA) && !BUILDFLAG(IS_BSD))
+ void ReportMallinfoStats(ProcessMemoryDump* pmd,
+                          size_t* total_virtual_size,
+                          size_t* resident_size,
+@@ -356,6 +358,9 @@ bool MallocDumpProvider::OnMemoryDump(const MemoryDump
+                      &allocated_objects_count);
+ #elif BUILDFLAG(IS_FUCHSIA)
+ // TODO(fuchsia): Port, see https://crbug.com/706592.
++#elif defined(OS_BSD)
++  total_virtual_size = 0;
++  allocated_objects_size = 0;
+ #else
+   ReportMallinfoStats(/*pmd=*/nullptr, &total_virtual_size, &resident_size,
+                       &allocated_objects_size, &allocated_objects_count);

www/ungoogled-chromium/files/patch-base_trace__event_memory__dump__manager.cc

@@ -0,0 +1,11 @@
+--- base/trace_event/memory_dump_manager.cc.orig	2022-10-01 07:40:07 UTC
++++ base/trace_event/memory_dump_manager.cc
+@@ -82,7 +82,7 @@ const char* const MemoryDumpManager::kSystemAllocatorP
+ #if defined(MALLOC_MEMORY_TRACING_SUPPORTED)
+     MallocDumpProvider::kAllocatedObjects;
+ #else
+-    nullptr;
++    "";
+ #endif
+ 
+ // static

www/ungoogled-chromium/files/patch-base_trace__event_process__memory__dump.cc

@@ -0,0 +1,20 @@
+--- base/trace_event/process_memory_dump.cc.orig	2022-10-01 07:40:07 UTC
++++ base/trace_event/process_memory_dump.cc
+@@ -112,7 +112,7 @@ absl::optional<size_t> ProcessMemoryDump::CountResiden
+ #if BUILDFLAG(IS_WIN)
+   std::unique_ptr<PSAPI_WORKING_SET_EX_INFORMATION[]> vec(
+       new PSAPI_WORKING_SET_EX_INFORMATION[max_vec_size]);
+-#elif BUILDFLAG(IS_APPLE)
++#elif BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_BSD)
+   std::unique_ptr<char[]> vec(new char[max_vec_size]);
+ #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
+   std::unique_ptr<unsigned char[]> vec(new unsigned char[max_vec_size]);
+@@ -134,7 +134,7 @@ absl::optional<size_t> ProcessMemoryDump::CountResiden
+ 
+     for (size_t i = 0; i < page_count; i++)
+       resident_page_count += vec[i].VirtualAttributes.Valid;
+-#elif BUILDFLAG(IS_FUCHSIA)
++#elif BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_BSD)
+     // TODO(crbug.com/851760): Implement counting resident bytes.
+     // For now, log and avoid unused variable warnings.
+     NOTIMPLEMENTED_LOG_ONCE();