Update sentry-native to 0.7.2

thirdparty/sentry-native/CHANGELOG.md

@@ -1,11 +1,68 @@
 # Changelog
 
+## 0.7.2
+
+**Features**:
+
+- Add optional Gzip transport compression via build option `SENTRY_TRANSPORT_COMPRESSION`. Requires system `zlib`. ([#954](https://github.com/getsentry/sentry-native/pull/954))
+- Enable automatic MIME detection of attachments sent with crash-reports from the `crashpad_handler`. ([#973](https://github.com/getsentry/sentry-native/pull/973), [crashpad#98](https://github.com/getsentry/crashpad/pull/98))
+
+**Fixes**:
+
+- Fix the Linux build when targeting RISC-V. ([#972](https://github.com/getsentry/sentry-native/pull/972))
+
+**Thank you**:
+
+- [@Strive-Sun](https://github.com/Strive-Sun)
+- [@jwinarske](https://github.com/jwinarske)
+
+## 0.7.1
+
+**Features**:
+
+- Add user feedback capability to the Native SDK. ([#966](https://github.com/getsentry/sentry-native/pull/966))
+
+**Internal**:
+
+- Remove the `CRASHPAD_WER_ENABLED` build flag. The WER module is now built for all supported Windows targets, and registration is conditional on runtime Windows version checks. ([#950](https://github.com/getsentry/sentry-native/pull/950), [crashpad#96](https://github.com/getsentry/crashpad/pull/96))
+
+**Docs**:
+
+- Add usage of the breadcrumb `data` property to the example. [#951](https://github.com/getsentry/sentry-native/pull/951)
+
+## 0.7.0
+
+**Breaking changes**:
+
+- Make `crashpad` the default backend for Linux. ([#927](https://github.com/getsentry/sentry-native/pull/927))
+- Remove build option `SENTRY_CRASHPAD_SYSTEM`. ([#928](https://github.com/getsentry/sentry-native/pull/928))
+
+**Fixes**:
+
+- Maintain `crashpad` client instance during Native SDK lifecycle. ([#910](https://github.com/getsentry/sentry-native/pull/910))
+- Specify correct dependencies for CMake client projects using a system-provided breakpad. ([#926](https://github.com/getsentry/sentry-native/pull/926))
+- Correct the Windows header include used by `sentry.h`, which fixes the build of [Swift bindings](https://github.com/thebrowsercompany/swift-sentry). ([#935](https://github.com/getsentry/sentry-native/pull/935))
+
+**Internal**:
+
+- Updated `crashpad` to 2023-11-24. ([#912](https://github.com/getsentry/sentry-native/pull/912), [crashpad#91](https://github.com/getsentry/crashpad/pull/91))
+- Fixing `crashpad` build for Windows on ARM64. ([#919](https://github.com/getsentry/sentry-native/pull/919), [crashpad#90](https://github.com/getsentry/crashpad/pull/90), [crashpad#92](https://github.com/getsentry/crashpad/pull/92), [crashpad#93](https://github.com/getsentry/crashpad/pull/93), [crashpad#94](https://github.com/getsentry/crashpad/pull/94))
+- Remove options memory leak during consent setting. ([#922](https://github.com/getsentry/sentry-native/pull/922))
+
+**Thank you**:
+
+Features, fixes and improvements in this release have been contributed by:
+
+- [@compnerd](https://github.com/compnerd)
+- [@stima](https://github.com/stima)
+- [@hyp](https://github.com/hyp)
+
 ## 0.6.7
 
 **Fixes**:
 
-- Disable sigaltstack on Android ([#901](https://github.com/getsentry/sentry-native/pull/901))
-- Prevent stuck crashpad-client on Windows ([#902](https://github.com/getsentry/sentry-native/pull/902), [crashpad#89](https://github.com/getsentry/crashpad/pull/89))
+- Disable sigaltstack on Android. ([#901](https://github.com/getsentry/sentry-native/pull/901))
+- Prevent stuck crashpad-client on Windows. ([#902](https://github.com/getsentry/sentry-native/pull/902), [crashpad#89](https://github.com/getsentry/crashpad/pull/89))
 
 ## 0.6.6
 

thirdparty/sentry-native/CMakeLists.txt

@@ -26,11 +26,11 @@ if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
 endif()
 
 if(NOT CMAKE_C_STANDARD)
-  set(CMAKE_C_STANDARD 11)
+	set(CMAKE_C_STANDARD 11)
 endif()
 
 if(NOT CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 17)
+	set(CMAKE_CXX_STANDARD 17)
 endif()
 
 include(GNUInstallDirs)
@@ -55,6 +55,8 @@ endif()
 
 option(SENTRY_PIC "Build sentry (and dependent) libraries as position independent libraries" ON)
 
+option(SENTRY_TRANSPORT_COMPRESSION "Enable transport gzip compression" OFF)
+
 option(SENTRY_BUILD_TESTS "Build sentry-native tests" "${SENTRY_MAIN_PROJECT}")
 option(SENTRY_BUILD_EXAMPLES "Build sentry-native example(s)" "${SENTRY_MAIN_PROJECT}")
 
@@ -96,7 +98,7 @@ else()
 endif()
 
 set(SENTRY_TRANSPORT ${SENTRY_DEFAULT_TRANSPORT} CACHE STRING
-  "The HTTP transport that sentry uses to submit events to the sentry server, can be either 'none', 'curl' or 'winhttp' on windows.")
+	"The HTTP transport that sentry uses to submit events to the sentry server, can be either 'none', 'curl' or 'winhttp' on windows.")
 
 if(SENTRY_TRANSPORT STREQUAL "winhttp")
 	set(SENTRY_TRANSPORT_WINHTTP TRUE)
@@ -125,10 +127,8 @@ option(SENTRY_ENABLE_INSTALL "Enable sentry installation" "${SENTRY_MAIN_PROJECT
 if(MSVC AND CMAKE_GENERATOR_TOOLSET MATCHES "_xp$")
 	message(WARNING "Crashpad is not supported for MSVC with XP toolset. Default backend was switched to 'breakpad'")
 	set(SENTRY_DEFAULT_BACKEND "breakpad")
-elseif((APPLE AND NOT IOS) OR WIN32)
+elseif((APPLE AND NOT IOS) OR WIN32 OR LINUX)
 	set(SENTRY_DEFAULT_BACKEND "crashpad")
-elseif(LINUX)
-	set(SENTRY_DEFAULT_BACKEND "breakpad")
 else()
 	set(SENTRY_DEFAULT_BACKEND "inproc")
 endif()
@@ -280,17 +280,20 @@ if(SENTRY_TRANSPORT_CURL)
 		find_package(CURL REQUIRED COMPONENTS AsynchDNS)
 	endif()
 
-	if(TARGET CURL::libcurl) # Only available in cmake 3.12+
-		target_link_libraries(sentry PRIVATE CURL::libcurl)
-	else()
-		# Needed for cmake < 3.12 support (cmake 3.12 introduced the target CURL::libcurl)
-		target_include_directories(sentry PRIVATE ${CURL_INCLUDE_DIR})
-		# The exported sentry target must not contain any path of the build machine, therefore use generator expressions
-		string(REPLACE ";" "$<SEMICOLON>" GENEX_CURL_LIBRARIES "${CURL_LIBRARIES}")
-		string(REPLACE ";" "$<SEMICOLON>" GENEX_CURL_COMPILE_DEFINITIONS "${CURL_COMPILE_DEFINITIONS}")
-		target_link_libraries(sentry PRIVATE $<BUILD_INTERFACE:${GENEX_CURL_LIBRARIES}>)
-		target_compile_definitions(sentry PRIVATE $<BUILD_INTERFACE:${GENEX_CURL_COMPILE_DEFINITIONS}>)
+	target_link_libraries(sentry PRIVATE CURL::libcurl)
+endif()
+
+if(SENTRY_TRANSPORT_COMPRESSION)
+	if(NOT ZLIB_FOUND)
+		find_package(ZLIB REQUIRED)
 	endif()
+
+	if(SENTRY_BACKEND_CRASHPAD)
+		set(CRASHPAD_ZLIB_SYSTEM ON CACHE BOOL "Force CRASHPAD_ZLIB_SYSTEM when enabling transport compression" FORCE)
+	endif()
+
+	target_link_libraries(sentry PRIVATE ZLIB::ZLIB)
+	target_compile_definitions(sentry PRIVATE SENTRY_TRANSPORT_COMPRESSION)
 endif()
 
 set_property(TARGET sentry PROPERTY C_VISIBILITY_PRESET hidden)
@@ -367,11 +370,11 @@ endif()
 
 # handle platform libraries
 if(ANDROID)
-    set(_SENTRY_PLATFORM_LIBS "dl" "log")
+	set(_SENTRY_PLATFORM_LIBS "dl" "log")
 elseif(LINUX)
-    set(_SENTRY_PLATFORM_LIBS "dl" "rt")
+	set(_SENTRY_PLATFORM_LIBS "dl" "rt")
 elseif(WIN32)
-    set(_SENTRY_PLATFORM_LIBS "dbghelp" "shlwapi" "version")
+	set(_SENTRY_PLATFORM_LIBS "dbghelp" "shlwapi" "version")
 endif()
 
 if(SENTRY_TRANSPORT_WINHTTP)
@@ -385,9 +388,9 @@ endif()
 
 # apply platform libraries to sentry library
 if(SENTRY_LIBRARY_TYPE STREQUAL "STATIC")
-    target_link_libraries(sentry PUBLIC ${_SENTRY_PLATFORM_LIBS})
+	target_link_libraries(sentry PUBLIC ${_SENTRY_PLATFORM_LIBS})
 else()
-    target_link_libraries(sentry PRIVATE ${_SENTRY_PLATFORM_LIBS})
+	target_link_libraries(sentry PRIVATE ${_SENTRY_PLATFORM_LIBS})
 endif()
 
 # suppress some errors and warnings for MinGW target
@@ -415,88 +418,73 @@ if(SENTRY_WITH_LIBUNWINDSTACK)
 endif()
 
 if(SENTRY_BACKEND_CRASHPAD)
-	option(SENTRY_CRASHPAD_SYSTEM "Use system crashpad" OFF)
-	if(SENTRY_CRASHPAD_SYSTEM)
-		find_package(crashpad REQUIRED)
-		target_link_libraries(sentry PUBLIC crashpad::client)
+	if(SENTRY_BUILD_SHARED_LIBS)
+		set(CRASHPAD_ENABLE_INSTALL OFF CACHE BOOL "Enable crashpad installation" FORCE)
 	else()
-		# FIXME: required for cmake 3.12 and lower:
-		# - NEW behavior lets normal variable override option
-		cmake_policy(SET CMP0077 NEW)
-		if(SENTRY_BUILD_SHARED_LIBS)
-			set(CRASHPAD_ENABLE_INSTALL OFF CACHE BOOL "Enable crashpad installation" FORCE)
-		else()
-			set(CRASHPAD_ENABLE_INSTALL ON CACHE BOOL "Enable crashpad installation" FORCE)
-		endif()
-		add_subdirectory(external/crashpad crashpad_build)
+		set(CRASHPAD_ENABLE_INSTALL ON CACHE BOOL "Enable crashpad installation" FORCE)
+	endif()
+	add_subdirectory(external/crashpad crashpad_build)
 
-		if(CRASHPAD_WER_ENABLED)
-			add_dependencies(sentry crashpad::wer)
-		endif()
+	if(WIN32)
+		add_dependencies(sentry crashpad::wer)
+	endif()
 
-		# set static runtime if enabled
-		if(SENTRY_BUILD_RUNTIMESTATIC AND MSVC)
-			set_property(TARGET crashpad_client PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-			set_property(TARGET crashpad_compat PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-			set_property(TARGET crashpad_getopt PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-			set_property(TARGET crashpad_handler PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-			set_property(TARGET crashpad_handler_lib PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-			set_property(TARGET crashpad_minidump PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-			set_property(TARGET crashpad_snapshot PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-			set_property(TARGET crashpad_tools PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-			set_property(TARGET crashpad_util PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-			if(CRASHPAD_WER_ENABLED)
-				set_property(TARGET crashpad_wer PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-			endif()
-			set_property(TARGET crashpad_zlib PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-			set_property(TARGET mini_chromium PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-		endif()
+	# set static runtime if enabled
+	if(SENTRY_BUILD_RUNTIMESTATIC AND MSVC)
+		set_property(TARGET crashpad_client PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+		set_property(TARGET crashpad_compat PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+		set_property(TARGET crashpad_getopt PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+		set_property(TARGET crashpad_handler PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+		set_property(TARGET crashpad_handler_lib PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+		set_property(TARGET crashpad_minidump PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+		set_property(TARGET crashpad_snapshot PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+		set_property(TARGET crashpad_tools PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+		set_property(TARGET crashpad_util PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+		set_property(TARGET crashpad_wer PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+		set_property(TARGET crashpad_zlib PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+		set_property(TARGET mini_chromium PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+	endif()
 
-		if(DEFINED SENTRY_FOLDER)
-			set_target_properties(crashpad_client PROPERTIES FOLDER ${SENTRY_FOLDER})
-			set_target_properties(crashpad_compat PROPERTIES FOLDER ${SENTRY_FOLDER})
-			set_target_properties(crashpad_getopt PROPERTIES FOLDER ${SENTRY_FOLDER})
-			set_target_properties(crashpad_handler PROPERTIES FOLDER ${SENTRY_FOLDER})
-			set_target_properties(crashpad_handler_lib PROPERTIES FOLDER ${SENTRY_FOLDER})
-			set_target_properties(crashpad_minidump PROPERTIES FOLDER ${SENTRY_FOLDER})
-			set_target_properties(crashpad_snapshot PROPERTIES FOLDER ${SENTRY_FOLDER})
-			set_target_properties(crashpad_tools PROPERTIES FOLDER ${SENTRY_FOLDER})
-			set_target_properties(crashpad_util PROPERTIES FOLDER ${SENTRY_FOLDER})
-			set_target_properties(crashpad_zlib PROPERTIES FOLDER ${SENTRY_FOLDER})
-			set_target_properties(mini_chromium PROPERTIES FOLDER ${SENTRY_FOLDER})
-			if(CRASHPAD_WER_ENABLED)
-				set_target_properties(crashpad_wer PROPERTIES FOLDER ${SENTRY_FOLDER})
-			endif()
-		endif()
+	if(DEFINED SENTRY_FOLDER)
+		set_target_properties(crashpad_client PROPERTIES FOLDER ${SENTRY_FOLDER})
+		set_target_properties(crashpad_compat PROPERTIES FOLDER ${SENTRY_FOLDER})
+		set_target_properties(crashpad_getopt PROPERTIES FOLDER ${SENTRY_FOLDER})
+		set_target_properties(crashpad_handler PROPERTIES FOLDER ${SENTRY_FOLDER})
+		set_target_properties(crashpad_handler_lib PROPERTIES FOLDER ${SENTRY_FOLDER})
+		set_target_properties(crashpad_minidump PROPERTIES FOLDER ${SENTRY_FOLDER})
+		set_target_properties(crashpad_snapshot PROPERTIES FOLDER ${SENTRY_FOLDER})
+		set_target_properties(crashpad_tools PROPERTIES FOLDER ${SENTRY_FOLDER})
+		set_target_properties(crashpad_util PROPERTIES FOLDER ${SENTRY_FOLDER})
+		set_target_properties(crashpad_zlib PROPERTIES FOLDER ${SENTRY_FOLDER})
+		set_target_properties(mini_chromium PROPERTIES FOLDER ${SENTRY_FOLDER})
+		set_target_properties(crashpad_wer PROPERTIES FOLDER ${SENTRY_FOLDER})
+	endif()
 
-		target_link_libraries(sentry PRIVATE
-			$<BUILD_INTERFACE:crashpad::client>
-			$<INSTALL_INTERFACE:sentry_crashpad::client>
-		)
-		install(EXPORT crashpad_export NAMESPACE sentry_crashpad:: FILE sentry_crashpad-targets.cmake
-			DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
-		)
-		if(WIN32 AND MSVC)
-			sentry_install(FILES $<TARGET_PDB_FILE:crashpad_handler>
-				DESTINATION "${CMAKE_INSTALL_BINDIR}" OPTIONAL)
-			if (CRASHPAD_WER_ENABLED)
-				sentry_install(FILES $<TARGET_PDB_FILE:crashpad_wer>
-					DESTINATION "${CMAKE_INSTALL_BINDIR}" OPTIONAL)
-			endif()
-		endif()
+	target_link_libraries(sentry PRIVATE
+		$<BUILD_INTERFACE:crashpad::client>
+		$<INSTALL_INTERFACE:sentry_crashpad::client>
+	)
+	install(EXPORT crashpad_export NAMESPACE sentry_crashpad:: FILE sentry_crashpad-targets.cmake
+		DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
+	)
+	if(WIN32 AND MSVC)
+		sentry_install(FILES $<TARGET_PDB_FILE:crashpad_handler>
+			DESTINATION "${CMAKE_INSTALL_BINDIR}" OPTIONAL)
+		sentry_install(FILES $<TARGET_PDB_FILE:crashpad_wer>
+			DESTINATION "${CMAKE_INSTALL_BINDIR}" OPTIONAL)
 	endif()
 	add_dependencies(sentry crashpad::handler)
-
-	if(CRASHPAD_WER_ENABLED)
-		add_compile_definitions(CRASHPAD_WER_ENABLED)
-	endif()
 elseif(SENTRY_BACKEND_BREAKPAD)
 	option(SENTRY_BREAKPAD_SYSTEM "Use system breakpad" OFF)
 	if(SENTRY_BREAKPAD_SYSTEM)
 		# system breakpad is using pkg-config, see `external/breakpad/breakpad-client.pc.in`
 		find_package(PkgConfig REQUIRED)
 		pkg_check_modules(BREAKPAD REQUIRED IMPORTED_TARGET breakpad-client)
-		target_link_libraries(sentry PUBLIC PkgConfig::BREAKPAD)
+		if(SENTRY_BUILD_SHARED_LIBS)
+			target_link_libraries(sentry PRIVATE PkgConfig::BREAKPAD)
+		else()
+			target_link_libraries(sentry PUBLIC PkgConfig::BREAKPAD)
+		endif()
 	else()
 		add_subdirectory(external)
 		target_include_directories(sentry PRIVATE
@@ -579,10 +567,9 @@ if(SENTRY_BUILD_EXAMPLES)
 
 	if(MSVC)
 		target_compile_options(sentry_example PRIVATE $<BUILD_INTERFACE:/wd5105>)
-		if(CRASHPAD_WER_ENABLED)
-			# to test handling SEH by-passing exceptions we need to enable the control flow guard
-			target_compile_options(sentry_example PRIVATE $<BUILD_INTERFACE:/guard:cf>)
-		endif()
+
+		# to test handling SEH by-passing exceptions we need to enable the control flow guard
+		target_compile_options(sentry_example PRIVATE $<BUILD_INTERFACE:/guard:cf>)
 	endif()
 
 	# set static runtime if enabled
@@ -608,4 +595,4 @@ endif()
 if(SENTRY_BUILD_SHARED_LIBS)
 	target_link_libraries(sentry PRIVATE
 			"$<$<OR:$<PLATFORM_ID:Linux>,$<PLATFORM_ID:Android>>:-Wl,--build-id=sha1,--version-script=${PROJECT_SOURCE_DIR}/src/exports.map>")
-endif()
+endif()

thirdparty/sentry-native/README.md

@@ -17,6 +17,10 @@ applications, optimized for C and C++. Sentry allows to add tags, breadcrumbs
 and arbitrary custom context to enrich error reports. Supports Sentry _20.6.0_
 and later.
 
+### Note <!-- omit in toc -->
+
+Using the `sentry-native` SDK in a standalone use case is currently an experimental feature. The SDK’s primary function is to fuel our other SDKs, like [`sentry-java`](https://github.com/getsentry/sentry-java) or [`sentry-unreal`](https://github.com/getsentry/sentry-unreal). Support from our side is best effort and we do what we can to respond to issues in a timely fashion, but please understand if we won’t be able to address your issues or feature suggestions.
+
 ## Resources <!-- omit in toc -->
 
 - [SDK Documentation](https://docs.sentry.io/platforms/native/)
@@ -227,9 +231,9 @@ using `cmake -D BUILD_SHARED_LIBS=OFF ..`.
   Sentry can use different backends depending on platform.
 
   - **crashpad**: This uses the out-of-process crashpad handler. It is currently
-    only supported on Desktop OSs, and used as the default on Windows and macOS.
+    only supported on Desktop OSs, and used as the default on Windows, Linux and macOS.
   - **breakpad**: This uses the in-process breakpad handler. It is currently
-    only supported on Desktop OSs, and used as the default on Linux.
+    only supported on Desktop OSs.
   - **inproc**: A small in-process handler which is supported on all platforms,
     and is used as default on Android.
   - **none**: This builds `sentry-native` without a backend, so it does not handle
@@ -238,12 +242,8 @@ using `cmake -D BUILD_SHARED_LIBS=OFF ..`.
 - `SENTRY_INTEGRATION_QT` (Default: OFF):
   Builds the Qt integration, which turns Qt log messages into breadcrumbs.
 
-- `SENTRY_BREAKPAD_SYSTEM` / `SENTRY_CRASHPAD_SYSTEM` (Default: OFF):
-  This instructs the build system to use system-installed breakpad or crashpad
-  libraries instead of using the in-tree version. This is generally not recommended
-  for crashpad, as sentry uses a patched version that has attachment support.
-  This is being worked on upstream as well, and a future version might work with
-  an unmodified crashpad version as well.
+- `SENTRY_BREAKPAD_SYSTEM` (Default: OFF):
+  This instructs the build system to use system-installed breakpad libraries instead of using the in-tree version.
 
 | Feature    | Windows | macOS | Linux | Android | iOS |
 | ---------- | ------- | ----- | ----- | ------- | --- |

thirdparty/sentry-native/examples/example.c

@@ -9,17 +9,21 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #ifdef NDEBUG
 #    undef NDEBUG
 #endif
+
 #include <assert.h>
 
 #ifdef SENTRY_PLATFORM_WINDOWS
 #    include <synchapi.h>
 #    define sleep_s(SECONDS) Sleep((SECONDS)*1000)
 #else
+
 #    include <signal.h>
 #    include <unistd.h>
+
 #    define sleep_s(SECONDS) sleep(SECONDS)
 #endif
 
@@ -93,7 +97,9 @@ has_arg(int argc, char **argv, const char *arg)
     return false;
 }
 
-#ifdef CRASHPAD_WER_ENABLED
+#if defined(SENTRY_PLATFORM_WINDOWS) && !defined(__MINGW32__)                  \
+    && !defined(__MINGW64__)
+
 int
 call_rffe_many_times()
 {
@@ -138,7 +144,7 @@ trigger_fastfail_crash()
     __fastfail(77);
 }
 
-#endif // CRASHPAD_WER_ENABLED
+#endif
 
 #ifdef SENTRY_PLATFORM_AIX
 // AIX has a null page mapped to the bottom of memory, which means null derefs
@@ -258,6 +264,21 @@ main(int argc, char **argv)
             debug_crumb, "category", sentry_value_new_string("example!"));
         sentry_value_set_by_key(
             debug_crumb, "level", sentry_value_new_string("debug"));
+
+        // extend the `http` crumb with (optional) data properties as documented
+        // here:
+        // https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#breadcrumb-types
+        sentry_value_t http_data = sentry_value_new_object();
+        sentry_value_set_by_key(http_data, "url",
+            sentry_value_new_string("https://example.com/api/1.0/users"));
+        sentry_value_set_by_key(
+            http_data, "method", sentry_value_new_string("GET"));
+        sentry_value_set_by_key(
+            http_data, "status_code", sentry_value_new_int32(200));
+        sentry_value_set_by_key(
+            http_data, "reason", sentry_value_new_string("OK"));
+        sentry_value_set_by_key(debug_crumb, "data", http_data);
+
         sentry_add_breadcrumb(debug_crumb);
 
         sentry_value_t nl_crumb
@@ -301,7 +322,8 @@ main(int argc, char **argv)
     if (has_arg(argc, argv, "crash")) {
         trigger_crash();
     }
-#ifdef CRASHPAD_WER_ENABLED
+#if defined(SENTRY_PLATFORM_WINDOWS) && !defined(__MINGW32__)                  \
+    && !defined(__MINGW64__)
     if (has_arg(argc, argv, "fastfail")) {
         trigger_fastfail_crash();
     }
@@ -343,6 +365,16 @@ main(int argc, char **argv)
 
         sentry_capture_event(event);
     }
+    if (has_arg(argc, argv, "capture-user-feedback")) {
+        sentry_value_t event = sentry_value_new_message_event(
+            SENTRY_LEVEL_INFO, "my-logger", "Hello user feedback!");
+        sentry_uuid_t event_id = sentry_capture_event(event);
+
+        sentry_value_t user_feedback = sentry_value_new_user_feedback(
+            &event_id, "some-name", "some-email", "some-comment");
+
+        sentry_capture_user_feedback(user_feedback);
+    }
 
     if (has_arg(argc, argv, "capture-transaction")) {
         sentry_transaction_context_t *tx_ctx

thirdparty/sentry-native/external/crashpad/.github/workflows/build.yml

@@ -34,6 +34,18 @@ jobs:
           cmake -B cmake-build-stacks -D CRASHPAD_ENABLE_STACKTRACE=ON
           cmake --build cmake-build-stacks --parallel
 
+      - name: Build crashpad Windows ARM64
+        if: ${{ runner.os == 'Windows' }}
+        run: |
+          cmake -B cmake-build-arm64 -DCMAKE_TOOLCHAIN_FILE="cmake/toolchains/win_arm64.cmake" -DCRASHPAD_BUILD_TOOLS=On
+          cmake --build cmake-build-arm64 --config RelWithDebInfo -- /p:Platform=ARM64
+
+      - name: Build crashpad with client-side stack traces Windows ARM64
+        if: ${{ runner.os == 'Windows' }}
+        run: |
+          cmake -B cmake-build-stacks-arm64 -DCMAKE_TOOLCHAIN_FILE="cmake/toolchains/win_arm64.cmake" -DCRASHPAD_ENABLE_STACKTRACE=ON
+          cmake --build cmake-build-stacks-arm64 --config RelWithDebInfo -- /p:Platform=ARM64
+
   build-ios:
     runs-on: macos-latest
     steps:

thirdparty/sentry-native/external/crashpad/CMakeLists.txt

@@ -21,7 +21,7 @@ else()
 endif()
 option(CRASHPAD_ZLIB_SYSTEM "Use system zlib library" "${CRASHPAD_ZLIB_SYSTEM_DEFAULT}")
 
-if(CRASHPAD_ZLIB_SYSTEM)
+if(CRASHPAD_ZLIB_SYSTEM AND NOT ZLIB_FOUND)
     find_package(ZLIB REQUIRED)
 endif()
 
@@ -50,7 +50,11 @@ function(crashpad_install_dev)
 endfunction()
 
 if(WIN32)
-    enable_language(ASM_MASM)
+    if("${CMAKE_SYSTEM_PROCESSOR}" MATCHES ARM64)
+        enable_language(ASM_MARMASM)
+    else()
+        enable_language(ASM_MASM)
+    endif()
 
     if(MINGW)
         find_program(JWASM_FOUND jwasm)
@@ -119,24 +123,10 @@ if(MSVC)
         $<$<COMPILE_LANGUAGE:C,CXX>:/wd4577> # 'noexcept' used with no exception handling mode specified.
         $<$<COMPILE_LANGUAGE:C,CXX>:/wd4996> # 'X' was declared deprecated.
     )
-
-    # WER support is only available starting from Win10 build 10941
-    if("${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}" VERSION_LESS 10.0.19041)
-        message(STATUS "WER support disabled. Needs target platform >= 10.0.19041 (actual: ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION})")
-    else()
-        SET(CRASHPAD_WER_ENABLED TRUE)
-        SET(CRASHPAD_WER_ENABLED TRUE PARENT_SCOPE)
-        message(STATUS "WER support enabled")
-    endif()
 elseif(MINGW)
     # redirect to wmain
     # FIXME: cmake 3.13 added target_link_options
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -municode")
-    if(CRASHPAD_WER_ENABLED)
-        message(STATUS "WER support enabled")
-    else()
-        message(STATUS "WER support disabled. Define CRASHPAD_WER_ENABLED = TRUE to enable.")
-    endif()
 endif()
 add_library(crashpad::interface ALIAS crashpad_interface)
 

thirdparty/sentry-native/external/crashpad/DEPS

@@ -47,13 +47,13 @@ deps = {
       '9719c1e1e676814c456b55f5f070eabad6709d31',
   'crashpad/third_party/mini_chromium/mini_chromium':
       Var('chromium_git') + '/chromium/mini_chromium@' +
-      '10f39a97650a0fe0b305415c15434443c0690a20',
+      '9e21183c1ea369398d6f6ddd302c8db580bd19c4',
   'crashpad/third_party/libfuzzer/src':
       Var('chromium_git') + '/chromium/llvm-project/compiler-rt/lib/fuzzer.git@' +
       'fda403cf93ecb8792cb1d061564d89a6553ca020',
   'crashpad/third_party/zlib/zlib':
       Var('chromium_git') + '/chromium/src/third_party/zlib@' +
-      '13dc246a58e4b72104d35f9b1809af95221ebda7',
+      'fef58692c1d7bec94c4ed3d030a45a1832a9615d',
 
   # CIPD packages.
   'buildtools/linux64': {
@@ -89,8 +89,8 @@ deps = {
   'crashpad/third_party/linux/clang/linux-amd64': {
     'packages': [
       {
-        'package': 'fuchsia/clang/linux-amd64',
-        'version': 'goma',
+        'package': 'fuchsia/third_party/clang/linux-amd64',
+        'version': 'Tpc85d1ZwSlZ6UKl2d96GRUBGNA5JKholOKe24sRDr0C',
       },
     ],
     'condition': 'checkout_linux and pull_linux_clang',
@@ -99,8 +99,8 @@ deps = {
   'crashpad/third_party/fuchsia/clang/mac-amd64': {
     'packages': [
       {
-        'package': 'fuchsia/clang/mac-amd64',
-        'version': 'goma',
+        'package': 'fuchsia/third_party/clang/mac-amd64',
+        'version': 'MAOjNhwTu5JU3P_0C9dITiyCTtQ1n7lRJnMfB9hhvOkC',
       },
     ],
     'condition': 'checkout_fuchsia and host_os == "mac"',
@@ -109,8 +109,8 @@ deps = {
   'crashpad/third_party/fuchsia/clang/linux-amd64': {
     'packages': [
       {
-        'package': 'fuchsia/clang/linux-amd64',
-        'version': 'goma',
+        'package': 'fuchsia/third_party/clang/linux-amd64',
+        'version': 'Tpc85d1ZwSlZ6UKl2d96GRUBGNA5JKholOKe24sRDr0C',
       },
     ],
     'condition': 'checkout_fuchsia and host_os == "linux"',

thirdparty/sentry-native/external/crashpad/build/ios/Unittest-Info.plist

@@ -3,7 +3,7 @@
 <plist version="1.0">
 <dict>
 	<key>CFBundleIdentifier</key>
-	<string>${IOS_BUNDLE_ID_PREFIX}.googletest.${GTEST_BUNDLE_ID_SUFFIX:rfc1034identifier}</string>
+	<string>${IOS_BUNDLE_ID_PREFIX}.${GTEST_BUNDLE_ID_SUFFIX:rfc1034identifier}</string>
 	<key>UIApplicationDelegate</key>
 	<string>CrashpadUnitTestDelegate</string>
 </dict>

thirdparty/sentry-native/external/crashpad/client/annotation.h

@@ -246,6 +246,14 @@ class Annotation {
 
   std::atomic<Annotation*>& link_node() { return link_node_; }
 
+  Annotation* GetLinkNode(std::memory_order order = std::memory_order_seq_cst) {
+    return link_node_.load(order);
+  }
+  const Annotation* GetLinkNode(
+      std::memory_order order = std::memory_order_seq_cst) const {
+    return link_node_.load(order);
+  }
+
  private:
   //! \brief Linked list next-node pointer. Accessed only by \sa AnnotationList.
   //!
@@ -323,9 +331,11 @@ class StringAnnotation : public Annotation {
   void Set(base::StringPiece string) {
     Annotation::ValueSizeType size =
         std::min(MaxSize, base::saturated_cast<ValueSizeType>(string.size()));
-    memcpy(value_, string.data(), size);
+    string = string.substr(0, size);
+    std::copy(string.begin(), string.end(), value_);
     // Check for no embedded `NUL` characters.
-    DCHECK(!memchr(value_, '\0', size)) << "embedded NUL";
+    DCHECK(string.find('\0', /*pos=*/0) == base::StringPiece::npos)
+        << "embedded NUL";
     SetSize(size);
   }
 

thirdparty/sentry-native/external/crashpad/client/annotation_list.cc

@@ -77,7 +77,7 @@ Annotation* AnnotationList::Iterator::operator*() const {
 
 AnnotationList::Iterator& AnnotationList::Iterator::operator++() {
   CHECK_NE(curr_, tail_);
-  curr_ = curr_->link_node();
+  curr_ = curr_->GetLinkNode();
   return *this;
 }
 
@@ -86,12 +86,42 @@ bool AnnotationList::Iterator::operator==(
   return curr_ == other.curr_;
 }
 
+AnnotationList::ConstIterator::ConstIterator(const Annotation* head,
+                                             const Annotation* tail)
+    : curr_(head), tail_(tail) {}
+
+AnnotationList::ConstIterator::~ConstIterator() = default;
+
+const Annotation* AnnotationList::ConstIterator::operator*() const {
+  CHECK_NE(curr_, tail_);
+  return curr_;
+}
+
+AnnotationList::ConstIterator& AnnotationList::ConstIterator::operator++() {
+  CHECK_NE(curr_, tail_);
+  curr_ = curr_->GetLinkNode();
+  return *this;
+}
+
+bool AnnotationList::ConstIterator::operator==(
+    const AnnotationList::ConstIterator& other) const {
+  return curr_ == other.curr_;
+}
+
 AnnotationList::Iterator AnnotationList::begin() {
-  return Iterator(head_.link_node(), tail_pointer_);
+  return Iterator(head_.GetLinkNode(), tail_pointer_);
+}
+
+AnnotationList::ConstIterator AnnotationList::cbegin() const {
+  return ConstIterator(head_.GetLinkNode(), tail_pointer_);
 }
 
 AnnotationList::Iterator AnnotationList::end() {
   return Iterator(&tail_, tail_pointer_);
 }
 
+AnnotationList::ConstIterator AnnotationList::cend() const {
+  return ConstIterator(&tail_, tail_pointer_);
+}
+
 }  // namespace crashpad

thirdparty/sentry-native/external/crashpad/client/annotation_list.h

@@ -80,11 +80,37 @@ class AnnotationList {
     // Copy and assign are required.
   };
 
+  //! \brief An InputIterator for iterating a const AnnotationList.
+  class ConstIterator {
+   public:
+    ~ConstIterator();
+
+    const Annotation* operator*() const;
+    ConstIterator& operator++();
+    bool operator==(const ConstIterator& other) const;
+    bool operator!=(const ConstIterator& other) const {
+      return !(*this == other);
+    }
+
+   private:
+    friend class AnnotationList;
+    ConstIterator(const Annotation* head, const Annotation* tail);
+
+    const Annotation* curr_;
+    const Annotation* const tail_;
+
+    // Copy and assign are required.
+  };
+
   //! \brief Returns an iterator to the first element of the annotation list.
   Iterator begin();
+  ConstIterator begin() const { return cbegin(); }
+  ConstIterator cbegin() const;
 
   //! \brief Returns an iterator past the last element of the annotation list.
   Iterator end();
+  ConstIterator end() const { return cend(); }
+  ConstIterator cend() const;
 
  protected:
 #if BUILDFLAG(IS_IOS)

thirdparty/sentry-native/external/crashpad/client/annotation_list_test.cc

@@ -128,6 +128,100 @@ TEST_F(AnnotationList, DuplicateKeys) {
   EXPECT_EQ(1u, annotations.size());
 }
 
+TEST_F(AnnotationList, IteratorSingleAnnotation) {
+  ASSERT_EQ(annotations_.begin(), annotations_.end());
+  ASSERT_EQ(annotations_.cbegin(), annotations_.cend());
+
+  one_.Set("1");
+
+  auto iterator = annotations_.begin();
+  auto const_iterator = annotations_.cbegin();
+
+  ASSERT_NE(iterator, annotations_.end());
+  ASSERT_NE(const_iterator, annotations_.cend());
+
+  EXPECT_EQ(*iterator, &one_);
+  EXPECT_EQ(*const_iterator, &one_);
+
+  ++iterator;
+  ++const_iterator;
+
+  EXPECT_EQ(iterator, annotations_.end());
+  EXPECT_EQ(const_iterator, annotations_.cend());
+}
+
+TEST_F(AnnotationList, IteratorMultipleAnnotationsInserted) {
+  ASSERT_EQ(annotations_.begin(), annotations_.end());
+  ASSERT_EQ(annotations_.cbegin(), annotations_.cend());
+
+  one_.Set("1");
+  two_.Set("2");
+
+  // New annotations are inserted to the beginning of the list. Hence, |two_|
+  // must be the first annotation, followed by |one_|.
+  {
+    auto iterator = annotations_.begin();
+    auto const_iterator = annotations_.cbegin();
+
+    ASSERT_NE(iterator, annotations_.end());
+    ASSERT_NE(const_iterator, annotations_.cend());
+
+    EXPECT_EQ(*iterator, &two_);
+    EXPECT_EQ(*const_iterator, &two_);
+
+    ++iterator;
+    ++const_iterator;
+
+    ASSERT_NE(iterator, annotations_.end());
+    ASSERT_NE(const_iterator, annotations_.cend());
+
+    EXPECT_EQ(*iterator, &one_);
+    EXPECT_EQ(*const_iterator, &one_);
+
+    ++iterator;
+    ++const_iterator;
+
+    EXPECT_EQ(iterator, annotations_.end());
+    EXPECT_EQ(const_iterator, annotations_.cend());
+  }
+}
+
+TEST_F(AnnotationList, IteratorMultipleAnnotationsInsertedAndRemoved) {
+  ASSERT_EQ(annotations_.begin(), annotations_.end());
+  ASSERT_EQ(annotations_.cbegin(), annotations_.cend());
+
+  one_.Set("1");
+  two_.Set("2");
+  one_.Clear();
+  two_.Clear();
+
+  // Even after clearing, Annotations are still inserted in the list and
+  // reachable via the iterators.
+  auto iterator = annotations_.begin();
+  auto const_iterator = annotations_.cbegin();
+
+  ASSERT_NE(iterator, annotations_.end());
+  ASSERT_NE(const_iterator, annotations_.cend());
+
+  EXPECT_EQ(*iterator, &two_);
+  EXPECT_EQ(*const_iterator, &two_);
+
+  ++iterator;
+  ++const_iterator;
+
+  ASSERT_NE(iterator, annotations_.end());
+  ASSERT_NE(const_iterator, annotations_.cend());
+
+  EXPECT_EQ(*iterator, &one_);
+  EXPECT_EQ(*const_iterator, &one_);
+
+  ++iterator;
+  ++const_iterator;
+
+  EXPECT_EQ(iterator, annotations_.end());
+  EXPECT_EQ(const_iterator, annotations_.cend());
+}
+
 class RaceThread : public Thread {
  public:
   explicit RaceThread(test::AnnotationList* test) : Thread(), test_(test) {}

thirdparty/sentry-native/external/crashpad/client/crash_report_database_generic.cc

@@ -22,6 +22,7 @@
 #include <tuple>
 #include <utility>
 
+#include "base/check_op.h"
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "client/settings.h"

thirdparty/sentry-native/external/crashpad/client/crash_report_database_mac.mm

@@ -34,8 +34,8 @@
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/scoped_generic.h"
+#include "base/strings/strcat.h"
 #include "base/strings/string_piece.h"
-#include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "client/settings.h"
 #include "util/file/directory_reader.h"
@@ -116,9 +116,9 @@ bool CreateOrEnsureDirectoryExists(const base::FilePath& path) {
 // have changed, and new_name determines whether the returned xattr name will be
 // the old name or its new equivalent.
 std::string XattrNameInternal(const base::StringPiece& name, bool new_name) {
-  return base::StringPrintf(new_name ? "org.chromium.crashpad.database.%s"
-                                     : "com.googlecode.crashpad.%s",
-                            name.data());
+  return base::StrCat({new_name ? "org.chromium.crashpad.database."
+                                : "com.googlecode.crashpad.",
+                       name});
 }
 
 }  // namespace

thirdparty/sentry-native/external/crashpad/client/crash_report_database_win.cc

@@ -25,6 +25,7 @@
 #include <tuple>
 #include <utility>
 
+#include "base/check_op.h"
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/utf_string_conversions.h"
@@ -545,8 +546,7 @@ void Metadata::Write() {
   for (const auto& report : reports_) {
     const base::FilePath& path = report.file_path;
     if (path.DirName() != report_dir_) {
-      LOG(ERROR) << path.value().c_str() << " expected to start with "
-                 << base::WideToUTF8(report_dir_.value());
+      LOG(ERROR) << path << " expected to start with " << report_dir_;
       return;
     }
     records.push_back(MetadataFileReportRecord(report, &string_table));
@@ -590,12 +590,11 @@ OperationStatus Metadata::VerifyReport(const ReportDisk& report_disk,
 bool EnsureDirectory(const base::FilePath& path) {
   DWORD fileattr = GetFileAttributes(path.value().c_str());
   if (fileattr == INVALID_FILE_ATTRIBUTES) {
-    PLOG(ERROR) << "GetFileAttributes " << base::WideToUTF8(path.value());
+    PLOG(ERROR) << "GetFileAttributes " << path;
     return false;
   }
   if ((fileattr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
-    LOG(ERROR) << "GetFileAttributes " << base::WideToUTF8(path.value())
-               << ": not a directory";
+    LOG(ERROR) << "GetFileAttributes " << path << ": not a directory";
     return false;
   }
   return true;
@@ -877,7 +876,7 @@ OperationStatus CrashReportDatabaseWin::DeleteReport(const UUID& uuid) {
     return os;
 
   if (!DeleteFile(report_path.value().c_str())) {
-    PLOG(ERROR) << "DeleteFile " << base::WideToUTF8(report_path.value());
+    PLOG(ERROR) << "DeleteFile " << report_path;
     return kFileSystemError;
   }
 
@@ -1021,8 +1020,7 @@ void CrashReportDatabaseWin::CleanOrphanedAttachments() {
     if (IsDirectory(path, false)) {
       UUID uuid;
       if (!uuid.InitializeFromString(filename.value())) {
-        LOG(ERROR) << "unexpected attachment dir name "
-                   << filename.value().c_str();
+        LOG(ERROR) << "unexpected attachment dir name " << filename;
         continue;
       }
 

thirdparty/sentry-native/external/crashpad/client/crashpad_client.h

@@ -835,11 +835,17 @@ class CrashpadClient {
 #endif
 
  private:
+#if BUILDFLAG(IS_WIN)
+  //!  \brief Registers process handlers for the client.
+  void RegisterHandlers();
+#endif
+
 #if BUILDFLAG(IS_APPLE)
   base::apple::ScopedMachSendRight exception_port_;
 #elif BUILDFLAG(IS_WIN)
   std::wstring ipc_pipe_;
   ScopedKernelHANDLE handler_start_thread_;
+  ScopedVectoredExceptionRegistration vectored_handler_;
 #elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
   std::set<int> unhandled_signals_;
 #endif  // BUILDFLAG(IS_APPLE)

thirdparty/sentry-native/external/crashpad/client/crashpad_client_fuchsia.cc

@@ -20,6 +20,7 @@
 #include <lib/zx/process.h>
 #include <zircon/processargs.h>
 
+#include "base/check_op.h"
 #include "base/fuchsia/fuchsia_logging.h"
 #include "base/logging.h"
 #include "client/client_argv_handling.h"

thirdparty/sentry-native/external/crashpad/client/crashpad_client_linux.cc

@@ -30,6 +30,7 @@
 
 #include <atomic>
 
+#include "base/check_op.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"

thirdparty/sentry-native/external/crashpad/client/crashpad_client_mac.cc

@@ -25,6 +25,7 @@
 #include <utility>
 
 #include "base/apple/mach_logging.h"
+#include "base/check_op.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "util/mac/mac_util.h"

thirdparty/sentry-native/external/crashpad/client/crashpad_client_win.cc

@@ -23,8 +23,10 @@
 #include <string.h>
 
 #include <memory>
+#include <string_view>
 
 #include "base/atomicops.h"
+#include "base/check_op.h"
 #include "base/logging.h"
 #include "base/scoped_generic.h"
 #include "base/strings/stringprintf.h"
@@ -203,6 +205,7 @@ LONG WINAPI UnhandledExceptionHandler(EXCEPTION_POINTERS* exception_pointers) {
   return EXCEPTION_CONTINUE_SEARCH;
 }
 
+#if !defined(ADDRESS_SANITIZER)
 LONG WINAPI HandleHeapCorruption(EXCEPTION_POINTERS* exception_pointers) {
   if (exception_pointers->ExceptionRecord->ExceptionCode ==
       STATUS_HEAP_CORRUPTION) {
@@ -211,6 +214,7 @@ LONG WINAPI HandleHeapCorruption(EXCEPTION_POINTERS* exception_pointers) {
 
   return EXCEPTION_CONTINUE_SEARCH;
 }
+#endif
 
 void HandleAbortSignal(int signum) {
   DCHECK_EQ(signum, SIGABRT);
@@ -537,7 +541,7 @@ bool StartHandlerProcess(
   // invalid command line where the first argument needed by rundll32 is not in
   // the correct format as required in:
   // https://support.microsoft.com/en-ca/help/164787/info-windows-rundll-and-rundll32-interface
-  const base::WStringPiece kRunDll32Exe(L"rundll32.exe");
+  const std::wstring_view kRunDll32Exe(L"rundll32.exe");
   bool is_embedded_in_dll = false;
   if (data->handler.value().size() >= kRunDll32Exe.size() &&
       _wcsicmp(data->handler.value()
@@ -609,45 +613,10 @@ void CommonInProcessInitialization() {
   g_non_crash_dump_lock = new base::Lock();
 }
 
-void RegisterHandlers() {
-  SetUnhandledExceptionFilter(&UnhandledExceptionHandler);
-
-  // Windows swallows heap corruption failures but we can intercept them with
-  // a vectored exception handler.
-#if defined(ADDRESS_SANITIZER)
-  // Let ASAN have first go.
-  bool go_first = false;
-#else
-  bool go_first = true;
-#endif
-  AddVectoredExceptionHandler(go_first, HandleHeapCorruption);
-
-  // The Windows CRT's signal.h lists:
-  // - SIGINT
-  // - SIGILL
-  // - SIGFPE
-  // - SIGSEGV
-  // - SIGTERM
-  // - SIGBREAK
-  // - SIGABRT
-  // SIGILL and SIGTERM are documented as not being generated. SIGBREAK and
-  // SIGINT are for Ctrl-Break and Ctrl-C, and aren't something for which
-  // capturing a dump is warranted. SIGFPE and SIGSEGV are captured as regular
-  // exceptions through the unhandled exception filter. This leaves SIGABRT. In
-  // the standard CRT, abort() is implemented as a synchronous call to the
-  // SIGABRT signal handler if installed, but after doing so, the unhandled
-  // exception filter is not triggered (it instead __fastfail()s). So, register
-  // to handle SIGABRT to catch abort() calls, as client code might use this and
-  // expect it to cause a crash dump. This will only work when the abort()
-  // that's called in client code is the same (or has the same behavior) as the
-  // one in use here.
-  void (*rv)(int) = signal(SIGABRT, HandleAbortSignal);
-  DCHECK_NE(rv, SIG_ERR);
-}
-
 }  // namespace
 
-CrashpadClient::CrashpadClient() : ipc_pipe_(), handler_start_thread_() {}
+CrashpadClient::CrashpadClient()
+    : ipc_pipe_(), handler_start_thread_(), vectored_handler_() {}
 
 CrashpadClient::~CrashpadClient() {}
 
@@ -723,6 +692,42 @@ bool CrashpadClient::StartHandler(
   }
 }
 
+void CrashpadClient::RegisterHandlers() {
+  SetUnhandledExceptionFilter(&UnhandledExceptionHandler);
+
+  // Windows swallows heap corruption failures but we can intercept them with
+  // a vectored exception handler. Note that a vectored exception handler is
+  // not compatible with or generally helpful in ASAN builds (ASAN inserts a
+  // bad dereference at the beginning of the handler, leading to recursive
+  // invocation of the handler).
+#if !defined(ADDRESS_SANITIZER)
+  PVOID handler = AddVectoredExceptionHandler(true, HandleHeapCorruption);
+  vectored_handler_.reset(handler);
+#endif
+
+  // The Windows CRT's signal.h lists:
+  // - SIGINT
+  // - SIGILL
+  // - SIGFPE
+  // - SIGSEGV
+  // - SIGTERM
+  // - SIGBREAK
+  // - SIGABRT
+  // SIGILL and SIGTERM are documented as not being generated. SIGBREAK and
+  // SIGINT are for Ctrl-Break and Ctrl-C, and aren't something for which
+  // capturing a dump is warranted. SIGFPE and SIGSEGV are captured as regular
+  // exceptions through the unhandled exception filter. This leaves SIGABRT. In
+  // the standard CRT, abort() is implemented as a synchronous call to the
+  // SIGABRT signal handler if installed, but after doing so, the unhandled
+  // exception filter is not triggered (it instead __fastfail()s). So, register
+  // to handle SIGABRT to catch abort() calls, as client code might use this and
+  // expect it to cause a crash dump. This will only work when the abort()
+  // that's called in client code is the same (or has the same behavior) as the
+  // one in use here.
+  void (*rv)(int) = signal(SIGABRT, HandleAbortSignal);
+  DCHECK_NE(rv, SIG_ERR);
+}
+
 bool CrashpadClient::SetHandlerIPCPipe(const std::wstring& ipc_pipe) {
   DCHECK(ipc_pipe_.empty());
   DCHECK(!ipc_pipe.empty());

thirdparty/sentry-native/external/crashpad/client/ios_handler/exception_processor.mm

@@ -324,6 +324,20 @@ bool ModulePathMatchesSinkhole(const char* path, const char* sinkhole) {
 #endif
 }
 
+//! \brief Helper to release memory from calls to __cxa_allocate_exception.
+class ScopedException {
+ public:
+  explicit ScopedException(objc_exception* exception) : exception_(exception) {}
+
+  ScopedException(const ScopedException&) = delete;
+  ScopedException& operator=(const ScopedException&) = delete;
+
+  ~ScopedException() { __cxxabiv1::__cxa_free_exception(exception_); }
+
+ private:
+  objc_exception* exception_;  // weak
+};
+
 id ObjcExceptionPreprocessor(id exception) {
   // Some sinkholes don't use objc_exception_rethrow when they should, which
   // would otherwise prevent the exception_preprocessor from getting called
@@ -384,6 +398,7 @@ id ObjcExceptionPreprocessor(id exception) {
   // From 10.15.0 objc4-779.1/runtime/objc-exception.mm objc_exception_throw.
   objc_exception* exception_objc = reinterpret_cast<objc_exception*>(
       __cxxabiv1::__cxa_allocate_exception(sizeof(objc_exception)));
+  ScopedException exception_objc_owner(exception_objc);
   exception_objc->obj = exception;
   exception_objc->tinfo.vtable = objc_ehtype_vtable + 2;
   exception_objc->tinfo.name = object_getClassName(exception);

thirdparty/sentry-native/external/crashpad/client/ios_handler/in_process_intermediate_dump_handler.cc

@@ -24,6 +24,7 @@
 #include <iterator>
 #include <optional>
 
+#include "base/check_op.h"
 #include "build/build_config.h"
 #include "snapshot/snapshot_constants.h"
 #include "util/ios/ios_intermediate_dump_writer.h"

thirdparty/sentry-native/external/crashpad/client/pthread_create_linux.cc

@@ -15,6 +15,7 @@
 #include <dlfcn.h>
 #include <pthread.h>
 
+#include "base/check.h"
 #include "base/logging.h"
 #include "client/crashpad_client.h"
 #include "util/misc/no_cfi_icall.h"

thirdparty/sentry-native/external/crashpad/cmake/toolchains/win_arm64.cmake

@@ -0,0 +1,6 @@
+# Toolchain file that should provide required and non-conflicting build-
+# parameters to allow normal and cross-compilation to ARM64 targets on 
+# Windows using any generator.
+SET(CMAKE_GENERATOR_PLATFORM "ARM64")
+SET(CMAKE_SYSTEM_PROCESSOR "ARM64")
+SET(CMAKE_SYSTEM_NAME "Windows")

thirdparty/sentry-native/external/crashpad/handler/CMakeLists.txt

@@ -123,7 +123,7 @@ if(NOT IOS)
     )
 endif()
 
-if(CRASHPAD_WER_ENABLED)
+if (WIN32)
     add_library(crashpad_wer SHARED
         win/wer/crashpad_wer.cc
         win/wer/crashpad_wer.h
@@ -147,4 +147,4 @@ if(CRASHPAD_WER_ENABLED)
     install(TARGETS crashpad_wer EXPORT crashpad_export
         RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
     )
-endif()
+endif()