Update Crashpad to 8e37886d418dd042c3c7bfadac99214739ee4d98

third_party/crashpad/crashpad/doc/developing.md

 <!--
 Copyright 2015 The Crashpad Authors. All rights reserved.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
@@ skipping 73 matching lines @@
 Crashpad uses [GYP](https://gyp.gsrc.io/) to generate
 [Ninja](https://ninja-build.org/) build files. The build is described by `.gyp`
 files throughout the Crashpad source code tree. The
 [`build/gyp_crashpad.py`](https://chromium.googlesource.com/crashpad/crashpad/+/master/build/gyp_crashpad.py)
 script runs GYP properly for Crashpad, and is also called when you run `fetch
 crashpad`, `gclient sync`, or `gclient runhooks`.
 
 The Ninja build files and build output are in the `out` directory. Both debug-
 and release-mode configurations are available. The examples below show the debug
 configuration. To build and test the release configuration, substitute `Release`
-for `Debug`.
+for `Debug`. On Windows, four configurations are available: `Debug` and
+`Release` produce 32-bit x86 executables, and `Debug_x64` and `Release_x64`
+produce x86_64 executables.
 
 ```
 $ cd ~/crashpad/crashpad
 $ ninja -C out/Debug
 ```
 
 Ninja is part of the
 [depot_tools](https://dev.chromium.org/developers/how-tos/depottools). There’s
 no need to install it separately.
 
 ### Android
 
 Crashpad’s Android port is in its early stages. This build relies on
 cross-compilation. It’s possible to develop Crashpad for Android on any platform
 that the [Android NDK (Native Development
 Kit)](https://developer.android.com/ndk/) runs on.
 
 If it’s not already present on your system, [download the NDK package for your
 system](https://developer.android.com/ndk/downloads/) and expand it to a
 suitable location. These instructions assume that it’s been expanded to
-`~/android-ndk-r13`.
+`~/android-ndk-r14`.
 
 To build Crashpad, portions of the NDK must be reassembled into a [standalone
 toolchain](https://developer.android.com/ndk/guides/standalone_toolchain.html).
 This is a repackaged subset of the NDK suitable for cross-compiling for a single
 Android architecture (such as `arm`, `arm64`, `x86`, and `x86_64`) targeting a
 specific [Android API
 level](https://source.android.com/source/build-numbers.html). The standalone
 toolchain only needs to be built from the NDK one time for each set of options
 desired. To build a standalone toolchain targeting 64-bit ARM and API level 21
 (Android 5.0 “Lollipop”), run:
 
 ```
 $ cd ~
-$ python android-ndk-r13/build/tools/make_standalone_toolchain.py \
-      --arch=arm64 --api=21 --install-dir=android-ndk-r13_arm64_api21
+$ python android-ndk-r14/build/tools/make_standalone_toolchain.py \
+      --arch=arm64 --api=21 --install-dir=android-ndk-r14_arm64_api21
 ```
 
 Note that Chrome uses Android API level 21 for 64-bit platforms and 16 for
 32-bit platforms. See Chrome’s
 [`build/config/android/config.gni`](https://chromium.googlesource.com/chromium/src/+/master/build/config/android/config.gni)
 which sets `_android_api_level` and `_android64_api_level`.
 
-To configure a Crashpad build for Android using this standalone toolchain, set
-several environment variables directing the build to the standalone toolchain,
-along with GYP options to identify an Android build. This must be done after any
-`gclient sync`, or instead of any `gclient runhooks` operation. The environment
-variables only need to be set for this `gyp_crashpad.py` invocation, and need
-not be permanent.
+To configure a Crashpad build for Android using the standalone toolchain
+assembled above, use `gyp_crashpad_android.py`. This script is a wrapper for
+`gyp_crashpad.py` that sets several environment variables directing the build to
+the standalone toolchain, and several GYP options to identify an Android build.
+This must be done after any `gclient sync`, or instead of any `gclient runhooks`
+operation.
 
 ```
 $ cd ~/crashpad/crashpad
-$ CC_target=~/android-ndk-r13_arm64_api21/bin/clang \
-  CXX_target=~/android-ndk-r13_arm64_api21/bin/clang++ \
-  AR_target=~/android-ndk-r13_arm64_api21/bin/aarch64-linux-android-ar \
-  NM_target=~/android-ndk-r13_arm64_api21/bin/aarch64-linux-android-nm \
-  READELF_target=~/android-ndk-r13_arm64_api21/bin/aarch64-linux-android-readelf \
-  python build/gyp_crashpad.py \
-      -DOS=android -Dtarget_arch=arm64 -Dclang=1 \
-      --generator-output=out_android_arm64_api21 -f ninja-android
+$ python build/gyp_crashpad_android.py \
+      --ndk ~/android-ndk-r14_arm64_api21 \
+      --generator-output out/android_arm64_api21
 ```
 
-It is also possible to use GCC instead of Clang by making the appropriate
-substitutions: `aarch64-linux-android-gcc` for `CC_target`;
-`aarch64-linux-android-g++` for `CXX_target`; and `-Dclang=0` as an argument to
-`gyp_crashpad.py`.
+`gyp_crashpad_android.py` detects the build type based on the characteristics of
+the standalone toolchain given in its `--ndk` argument.
 
-Target “triplets” to use for `ar`, `nm`, `readelf`, `gcc`, and `g++` are:
+`gyp_crashpad_android.py` sets the build up to use Clang by default. It’s also
+possible to use GCC by providing the `--compiler=gcc` argument to
+`gyp_crashpad_android.py`.
 
-| Architecture | Target “triplet”        |
-|:-------------|:------------------------|
-| `arm`        | `arm-linux-androideabi` |
-| `arm64`      | `aarch64-linux-android` |
-| `x86`        | `i686-linux-android`    |
-| `x86_64`     | `x86_64-linux-android`  |
-
-The port is incomplete, but targets known to be working include `crashpad_util`,
-`crashpad_test`, and `crashpad_test_test`. This list will grow over time. To
-build, direct `ninja` to the specific `out` directory chosen by
-`--generator-output` above.
+The Android port is incomplete, but targets known to be working include
+`crashpad_test`, `crashpad_util`, and their tests. This list will grow over
+time. To build, direct `ninja` to the specific `out` directory chosen by the
+`--generator-output` argument to `gyp_crashpad_android.py`.
 
 ```
-$ ninja -C out_android_arm64_api21/out/Debug crashpad_test_test
+$ ninja -C out/android_arm64_api21/out/Debug \
+      crashpad_test_test crashpad_util_test
 ```
 
 ## Testing
 
 Crashpad uses [Google Test](https://github.com/google/googletest/) as its
 unit-testing framework, and some tests use [Google
 Mock](https://github.com/google/googletest/tree/master/googlemock/) as well. Its
 tests are currently split up into several test executables, each dedicated to
 testing a different component. This may change in the future. After a successful
 build, the test executables will be found at `out/Debug/crashpad_*_test`.
 
 ```
 $ cd ~/crashpad/crashpad
 $ out/Debug/crashpad_minidump_test
 $ out/Debug/crashpad_util_test
 ```
 
 A script is provided to run all of Crashpad’s tests. It accepts a single
-argument that tells it which configuration to test.
+argument, a path to the directory containing the test executables.
 
 ```
 $ cd ~/crashpad/crashpad
-$ python build/run_tests.py Debug
+$ python build/run_tests.py out/Debug
 ```
 
 ### Android
 
 To test on Android, use [ADB (Android Debug
 Bridge)](https://developer.android.com/studio/command-line/adb.html) to `adb
 push` test executables and test data to a device or emulator, then use `adb
 shell` to get a shell to run the test executables from. ADB is part of the
 [Android SDK](https://developer.android.com/sdk/). Note that it is sufficient to
 install just the command-line tools. The entire Android Studio IDE is not
 necessary to obtain ADB.
 
 This example runs `crashpad_test_test` on a device. This test executable has a
 run-time dependency on a second executable and a test data file, which are also
 transferred to the device prior to running the test.
 
 ```
 $ cd ~/crashpad/crashpad
-$ adb push out_android_arm64_api21/out/Debug/crashpad_test_test /data/local/tmp/
+$ adb push out/android_arm64_api21/out/Debug/crashpad_test_test /data/local/tmp/
 [100%] /data/local/tmp/crashpad_test_test
 $ adb push \
-      out_android_arm64_api21/out/Debug/crashpad_test_test_multiprocess_exec_test_child \
+      out/android_arm64_api21/out/Debug/crashpad_test_test_multiprocess_exec_test_child \
       /data/local/tmp/
 [100%] /data/local/tmp/crashpad_test_test_multiprocess_exec_test_child
 $ adb shell mkdir -p /data/local/tmp/crashpad_test_data_root/test
 $ adb push test/paths_test_data_root.txt \
       /data/local/tmp/crashpad_test_data_root/test/
 [100%] /data/local/tmp/crashpad_test_data_root/test/paths_test_data_root.txt
 $ adb shell
 device:/ $ cd /data/local/tmp
 device:/data/local/tmp $ CRASHPAD_TEST_DATA_ROOT=crashpad_test_data_root \
                          ./crashpad_test_test
@@ skipping 82 matching lines @@
 file. Contributors may be listed in the
 [`CONTRIBUTORS`](https://chromium.googlesource.com/crashpad/crashpad/+/master/CONTRIBUTORS)
 file.
 
 ## Buildbot
 
 The [Crashpad Buildbot](https://build.chromium.org/p/client.crashpad/) performs
 automated builds and tests of Crashpad. Before checking out or updating the
 Crashpad source code, and after checking in a new change, it is prudent to check
 the Buildbot to ensure that “the tree is green.”