.github/workflows/build.yml

@@ -16,11 +16,11 @@ env:
   SCCACHE_CACHE_SIZE: 200M
 jobs:
   cache-toolchains-posix:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Cache toolchains (Linux, OpenWrt, Android)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             src/third_party/llvm-build/Release+Asserts/
@@ -28,32 +28,32 @@ jobs:
             src/qemu-user-static*.deb
           key: toolchains-posix-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache PGO (Linux, OpenWrt)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: src/chrome/build/pgo_profiles/
           key: pgo-linux-openwrt-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache AFDO (Android)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: src/chrome/android/profiles/
           key: afdo-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache Android NDK (Android)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
-          path: src/third_party/android_ndk/
+          path: src/third_party/android_toolchain/ndk/
           key: android-ndk-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - run: ./get-clang.sh
       - run: EXTRA_FLAGS='target_os="android"' ./get-clang.sh
       - run: |
           if [ ! -f qemu-user-static*.deb ]; then
-            wget https://snapshot.debian.org/archive/debian/20220515T152741Z/pool/main/q/qemu/qemu-user-static_7.0%2Bdfsg-6_amd64.deb
+            wget https://snapshot.debian.org/archive/debian/20230611T210420Z/pool/main/q/qemu/qemu-user-static_8.0%2Bdfsg-4_amd64.deb
           fi
   cache-toolchains-win:
-    runs-on: windows-2019
+    runs-on: windows-2022
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Cache toolchains
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             src/third_party/llvm-build/Release+Asserts/
@@ -62,12 +62,12 @@ jobs:
             ~/bin/ninja.exe
           key: toolchains-win-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache PGO (win64)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: src/chrome/build/pgo_profiles/chrome-win64-*
           key: pgo-win64-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache PGO (win32)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: src/chrome/build/pgo_profiles/chrome-win32-*
           key: pgo-win32-arm64-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
@@ -79,10 +79,10 @@ jobs:
             unzip ninja-win.zip -d ~/bin
           fi
   cache-toolchains-mac:
-    runs-on: macos-11
+    runs-on: macos-13
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
         with:
           path: |
             src/third_party/llvm-build/Release+Asserts/
@@ -93,18 +93,18 @@ jobs:
       - run: EXTRA_FLAGS='target_cpu="arm64"' ./get-clang.sh
   linux:
     needs: cache-toolchains-posix
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
-        arch: [x64, x86, arm64, arm, mipsel, mips64el]
+        arch: [x64, x86, arm64, arm, mipsel, mips64el, riscv64]
     env:
       EXTRA_FLAGS: 'target_cpu="${{ matrix.arch }}"'
       BUNDLE: naiveproxy-${{ github.event.release.tag_name }}-${{ github.job }}-${{ matrix.arch }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Cache toolchains (Linux, OpenWrt, Android)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             src/third_party/llvm-build/Release+Asserts/
@@ -112,29 +112,33 @@ jobs:
             src/qemu-user-static*.deb
           key: toolchains-posix-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache PGO (Linux, OpenWrt)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: src/chrome/build/pgo_profiles/
           key: pgo-linux-openwrt-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
+      - name: Regenerate Debian keyring
+        run: |
+          rm -f ./build/linux/sysroot_scripts/keyring.gpg
+          GPG_TTY=/dev/null ./build/linux/sysroot_scripts/generate_keyring.sh
       - name: Cache sysroot
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: src/out/sysroot-build/bullseye/bullseye_*
           key: sysroot-linux-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - id: ccache-timestamp
         run: echo "CCACHE_TIMESTAMP=$(date +%s)" >>$GITHUB_OUTPUT
       - name: Cache ccache files
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
-          path: ~/.ccache
+          path: ~/.cache/ccache
           key: ccache-linux-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-${{ steps.ccache-timestamp.outputs.CCACHE_TIMESTAMP }}
           restore-keys: ccache-linux-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-
       - name: Install APT packages
         run: |
           sudo apt update
-          sudo apt install ninja-build pkg-config qemu-user ccache bubblewrap
+          sudo apt install ninja-build pkg-config ccache bubblewrap
           sudo apt remove -y qemu-user-binfmt
-          sudo dpkg -i qemu-user-static_7.0+dfsg-6_amd64.deb
+          sudo dpkg -i qemu-user-static*.deb
           # libc6-i386 interferes with x86 build
           sudo apt remove libc6-i386
       - run: ./get-clang.sh
@@ -149,29 +153,41 @@ jobs:
           tar cJf ${{ env.BUNDLE }}.tar.xz ${{ env.BUNDLE }}
           openssl sha256 out/Release/naive >sha256sum.txt
           echo "SHA256SUM=$(cut -d' ' -f2 sha256sum.txt)" >>$GITHUB_ENV
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: ${{ env.BUNDLE }}.tar.xz naive executable sha256 ${{ env.SHA256SUM }}
           path: src/sha256sum.txt
       - name: Upload naiveproxy assets
         if: ${{ github.event_name == 'release' }}
-        run: hub release edit -a ${{ env.BUNDLE }}.tar.xz -m "" "${GITHUB_REF##*/}"
+        run: gh release upload "${GITHUB_REF##*/}" ${{ env.BUNDLE }}.tar.xz --clobber
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
   android:
     needs: cache-toolchains-posix
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
-        arch: [x64, x86, arm64, arm]
+        include:
+          - arch: x64
+            abi: x86_64
+          - arch: x86
+            abi: x86
+          - arch: arm64
+            abi: arm64-v8a
+          - arch: arm
+            abi: armeabi-v7a
     env:
       EXTRA_FLAGS: 'target_cpu="${{ matrix.arch }}" target_os="android"'
-      BUNDLE: naiveproxy-${{ github.event.release.tag_name }}-${{ github.job }}-${{ matrix.arch }}
+      BUNDLE: naiveproxy-plugin-${{ github.event.release.tag_name || 'v1.1.1.1-1' }}-${{ matrix.abi }}.apk
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
       - name: Cache toolchains (Linux, OpenWrt, Android)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             src/third_party/llvm-build/Release+Asserts/
@@ -179,34 +195,34 @@ jobs:
             src/qemu-user-static*.deb
           key: toolchains-posix-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache AFDO (Android)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: src/chrome/android/profiles/
           key: afdo-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache Android NDK (Android)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
-          path: src/third_party/android_ndk/
+          path: src/third_party/android_toolchain/ndk/
           key: android-ndk-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache sysroot
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: src/out/sysroot-build/android/
           key: sysroot-android-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - id: ccache-timestamp
         run: echo "CCACHE_TIMESTAMP=$(date +%s)" >>$GITHUB_OUTPUT
       - name: Cache ccache files
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
-          path: ~/.ccache
+          path: ~/.cache/ccache
           key: ccache-android-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-${{ steps.ccache-timestamp.outputs.CCACHE_TIMESTAMP }}
           restore-keys: ccache-android-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-
       - name: Install APT packages
         run: |
           sudo apt update
-          sudo apt install ninja-build pkg-config qemu-user ccache bubblewrap
+          sudo apt install ninja-build pkg-config ccache bubblewrap
           sudo apt remove -y qemu-user-binfmt
-          sudo dpkg -i qemu-user-static_7.0+dfsg-6_amd64.deb
+          sudo dpkg -i qemu-user-static*.deb
           # libc6-i386 interferes with x86 build
           sudo apt remove libc6-i386
       - run: ./get-clang.sh
@@ -215,25 +231,36 @@ jobs:
       - run: ccache -s
       - run: ./get-android-sys.sh
       - run: ../tests/basic.sh out/Release/naive
-      - name: Pack naiveproxy assets
-        run: |
-          mkdir ${{ env.BUNDLE }}
-          cp out/Release/naive config.json ../LICENSE ../USAGE.txt ${{ env.BUNDLE }}
-          tar cJf ${{ env.BUNDLE }}.tar.xz ${{ env.BUNDLE }}
-          openssl sha256 out/Release/naive >sha256sum.txt
-          echo "SHA256SUM=$(cut -d' ' -f2 sha256sum.txt)" >>$GITHUB_ENV
-      - uses: actions/upload-artifact@v3
+      - name: Gradle cache
+        uses: actions/cache@v4
         with:
-          name: ${{ env.BUNDLE }}.tar.xz naive executable sha256 ${{ env.SHA256SUM }}
-          path: src/sha256sum.txt
+          path: ~/.gradle
+          key: gradle-${{ hashFiles('**/*.gradle.kts') }}
+      - name: Create APK
+        working-directory: apk
+        env:
+          APK_ABI: ${{ matrix.abi }}
+          APK_VERSION_NAME: ${{ github.event.release.tag_name || 'v1.1.1.1-1' }}
+          KEYSTORE_PASS: ${{ secrets.KEYSTORE_PASS }}
+        run: |
+          mkdir -p app/libs/$APK_ABI
+          cp ../src/out/Release/naive app/libs/$APK_ABI/libnaive.so
+          ./gradlew :app:assembleRelease
+          openssl sha256 app/build/outputs/apk/release/${{ env.BUNDLE }} >sha256sum.txt
+          echo "SHA256SUM=$(cut -d' ' -f2 sha256sum.txt)" >>$GITHUB_ENV
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.BUNDLE }} sha256 ${{ env.SHA256SUM }}
+          path: apk/sha256sum.txt
       - name: Upload naiveproxy assets
         if: ${{ github.event_name == 'release' }}
-        run: hub release edit -a ${{ env.BUNDLE }}.tar.xz -m "" "${GITHUB_REF##*/}"
+        working-directory: apk/app/build/outputs/apk/release
+        run: gh release upload "${GITHUB_REF##*/}" ${{ env.BUNDLE }} --clobber
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
   win:
     needs: cache-toolchains-win
-    runs-on: windows-2019
+    runs-on: windows-2022
     strategy:
       fail-fast: false
       matrix:
@@ -242,9 +269,9 @@ jobs:
       EXTRA_FLAGS: 'target_cpu="${{ matrix.arch }}"'
       BUNDLE: naiveproxy-${{ github.event.release.tag_name }}-${{ github.job }}-${{ matrix.arch }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Cache toolchains
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             src/third_party/llvm-build/Release+Asserts/
@@ -254,20 +281,20 @@ jobs:
           key: toolchains-win-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache PGO (win64)
         if: ${{ matrix.arch == 'x64' }}
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: src/chrome/build/pgo_profiles/chrome-win64-*
           key: pgo-win64-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache PGO (win32)
         if: ${{ matrix.arch != 'x64' }}
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: src/chrome/build/pgo_profiles/chrome-win32-*
           key: pgo-win32-arm64-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - id: ccache-timestamp
         run: echo "CCACHE_TIMESTAMP=$(date +%s)" >>$GITHUB_OUTPUT
       - name: Cache ccache files
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: ~/AppData/Local/Mozilla/sccache
           key: ccache-win-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-${{ steps.ccache-timestamp.outputs.CCACHE_TIMESTAMP }}
@@ -286,18 +313,18 @@ jobs:
           7z a ${{ env.BUNDLE }}.zip ${{ env.BUNDLE }}
           openssl sha256 out/Release/naive.exe >sha256sum.txt
           echo "SHA256SUM=$(cut -d' ' -f2 sha256sum.txt)" >>$GITHUB_ENV
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: ${{ env.BUNDLE }}.zip naive executable sha256 ${{ env.SHA256SUM }}
           path: src/sha256sum.txt
       - name: Upload naiveproxy assets
         if: ${{ github.event_name == 'release' }}
-        run: hub release edit -a ${{ env.BUNDLE }}.zip -m "" "${GITHUB_REF##*/}"
+        run: gh release upload "${GITHUB_REF##*/}"  ${{ env.BUNDLE }}.zip --clobber
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
   mac:
     needs: cache-toolchains-mac
-    runs-on: macos-11
+    runs-on: macos-13
     strategy:
       fail-fast: false
       matrix:
@@ -306,9 +333,9 @@ jobs:
       EXTRA_FLAGS: 'target_cpu="${{ matrix.arch }}"'
       BUNDLE: naiveproxy-${{ github.event.release.tag_name }}-${{ github.job }}-${{ matrix.arch }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Cache toolchains and PGO
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             src/third_party/llvm-build/Release+Asserts/
@@ -318,12 +345,13 @@ jobs:
       - id: ccache-timestamp
         run: echo "CCACHE_TIMESTAMP=$(date +%s)" >>$GITHUB_OUTPUT
       - name: Cache ccache files
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: ~/Library/Caches/ccache
           key: ccache-mac-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-${{ steps.ccache-timestamp.outputs.CCACHE_TIMESTAMP }}
           restore-keys: ccache-mac-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-
       - run: brew install ninja ccache
+      - run: pip install setuptools
       - run: ./get-clang.sh
       - run: ccache -z
       - run: ./build.sh
@@ -338,156 +366,158 @@ jobs:
           tar cJf ${{ env.BUNDLE }}.tar.xz ${{ env.BUNDLE }}
           openssl sha256 out/Release/naive >sha256sum.txt
           echo "SHA256SUM=$(cut -d' ' -f2 sha256sum.txt)" >>$GITHUB_ENV
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: ${{ env.BUNDLE }}.tar.xz naive executable sha256 ${{ env.SHA256SUM }}
           path: src/sha256sum.txt
       - name: Upload naiveproxy assets
         if: ${{ github.event_name == 'release' }}
-        run: hub release edit -a ${{ env.BUNDLE }}.tar.xz -m "" "${GITHUB_REF##*/}"
+        run: gh release upload "${GITHUB_REF##*/}" ${{ env.BUNDLE }}.tar.xz --clobber
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-  ios:
-    needs: cache-toolchains-mac
-    runs-on: macos-11
-    strategy:
-      fail-fast: false
-      matrix:
-        arch: [arm64]
-    env:
-      EXTRA_FLAGS: 'target_cpu="${{ matrix.arch }}" target_os="ios" ios_enable_code_signing=false'
-      BUNDLE: naiveproxy-${{ github.event.release.tag_name }}-${{ github.job }}-${{ matrix.arch }}
-    steps:
-      - uses: actions/checkout@v3
-      - name: Cache toolchains and PGO
-        uses: actions/cache@v3
-        with:
-          path: |
-            src/third_party/llvm-build/Release+Asserts/
-            src/chrome/build/pgo_profiles/chrome-mac-*
-            src/gn/
-          key: toolchains-pgo-mac-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
-      - id: ccache-timestamp
-        run: echo "CCACHE_TIMESTAMP=$(date +%s)" >>$GITHUB_OUTPUT
-      - name: Cache ccache files
-        uses: actions/cache@v3
-        with:
-          path: ~/Library/Caches/ccache
-          key: ccache-ios-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-${{ steps.ccache-timestamp.outputs.CCACHE_TIMESTAMP }}
-          restore-keys: ccache-ios-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-
-      - run: brew install ninja ccache
-      - run: ./get-clang.sh
-      - run: ccache -z
-      - run: ./build.sh
-      - run: ccache -s
   openwrt:
     needs: cache-toolchains-posix
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
         include:
           - arch: x86_64
-            openwrt: 'target=x86 subtarget=64'
+            openwrt: "target=x86 subtarget=64"
             target_cpu: x64
           - arch: x86
-            openwrt: 'target=x86 subtarget=generic'
+            openwrt: "target=x86 subtarget=geode"
             target_cpu: x86
           - arch: aarch64_cortex-a53
-            openwrt: 'target=sunxi subtarget=cortexa53'
+            openwrt: "target=sunxi subtarget=cortexa53"
             target_cpu: arm64
             extra: 'arm_cpu="cortex-a53"'
           - arch: aarch64_cortex-a53-static
-            openwrt: 'target=sunxi subtarget=cortexa53'
+            openwrt: "target=sunxi subtarget=cortexa53"
             target_cpu: arm64
-            extra: 'arm_cpu="cortex-a53" build_static=true'
+            extra: 'arm_cpu="cortex-a53" build_static=true use_allocator_shim=false use_partition_alloc=false'
+            openwrt_release: '24.10.0'
+            openwrt_gcc_ver: '13.3.0'
           - arch: aarch64_cortex-a72
-            openwrt: 'target=mvebu subtarget=cortexa72'
+            openwrt: "target=mvebu subtarget=cortexa72"
             target_cpu: arm64
             extra: 'arm_cpu="cortex-a72"'
-          - arch: aarch64_generic
-            openwrt: 'target=rockchip subtarget=armv8'
+          - arch: aarch64_cortex-a72-static
+            openwrt: "target=mvebu subtarget=cortexa72"
             target_cpu: arm64
+            extra: 'arm_cpu="cortex-a72" build_static=true use_allocator_shim=false use_partition_alloc=false'
+            openwrt_release: '24.10.0'
+            openwrt_gcc_ver: '13.3.0'
+          - arch: aarch64_cortex-a76
+            openwrt: "target=bcm27xx subtarget=bcm2712"
+            target_cpu: arm64
+            extra: 'arm_cpu="cortex-a76"'
+            openwrt_release: '24.10.0'
+            openwrt_gcc_ver: '13.3.0'
+          - arch: aarch64_generic
+            openwrt: "target=layerscape subtarget=armv8_64b"
+            target_cpu: arm64
+          - arch: aarch64_generic-static
+            openwrt: "target=layerscape subtarget=armv8_64b"
+            target_cpu: arm64
+            extra: "build_static=true use_allocator_shim=false use_partition_alloc=false"
+            openwrt_release: '24.10.0'
+            openwrt_gcc_ver: '13.3.0'
           - arch: arm_arm1176jzf-s_vfp
-            openwrt: 'target=bcm27xx subtarget=bcm2708'
+            openwrt: "target=brcm2708 subtarget=bcm2708"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="arm1176jzf-s" arm_fpu="vfp" arm_float_abi="hard" arm_use_neon=false arm_use_thumb=false'
           - arch: arm_arm926ej-s
-            openwrt: 'target=mxs'
+            openwrt: "target=mxs subtarget=generic"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="arm926ej-s" arm_float_abi="soft" arm_use_neon=false arm_use_thumb=false'
           - arch: arm_cortex-a15_neon-vfpv4
-            openwrt: 'target=armvirt subtarget=32'
+            openwrt: "target=ipq806x subtarget=generic"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="cortex-a15" arm_fpu="neon-vfpv4" arm_float_abi="hard" arm_use_neon=true'
           - arch: arm_cortex-a5_vfpv4
-            openwrt: 'target=at91 subtarget=sama5'
+            openwrt: "target=at91 subtarget=sama5d3"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="cortex-a5" arm_fpu="vfpv4" arm_float_abi="hard" arm_use_neon=false'
           - arch: arm_cortex-a7
-            openwrt: 'target=mediatek subtarget=mt7629'
+            openwrt: "target=mediatek subtarget=mt7629"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="cortex-a7" arm_float_abi="soft" arm_use_neon=false'
+            openwrt_release: '21.02.0'
+            openwrt_gcc_ver: '8.4.0'
           - arch: arm_cortex-a7_neon-vfpv4
-            openwrt: 'target=sunxi subtarget=cortexa7'
+            openwrt: "target=sunxi subtarget=cortexa7"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="cortex-a7" arm_fpu="neon-vfpv4" arm_float_abi="hard" arm_use_neon=true'
+          - arch: arm_cortex-a7_neon-vfpv4-static
+            openwrt: "target=sunxi subtarget=cortexa7"
+            target_cpu: arm
+            extra: 'arm_version=0 arm_cpu="cortex-a7" arm_fpu="neon-vfpv4" arm_float_abi="hard" arm_use_neon=true build_static=true use_allocator_shim=false use_partition_alloc=false'
+            openwrt_release: '24.10.0'
+            openwrt_gcc_ver: '13.3.0'
           - arch: arm_cortex-a7_vfpv4
-            openwrt: 'target=at91 subtarget=sama7'
+            openwrt: "target=at91 subtarget=sama7"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="cortex-a7" arm_fpu="vfpv4" arm_float_abi="hard" arm_use_neon=false'
-          - arch: arm_cortex-a7_neon-vfpv4-static
-            openwrt: 'target=sunxi subtarget=cortexa7'
-            target_cpu: arm
-            extra: 'arm_version=0 arm_cpu="cortex-a7" arm_fpu="neon-vfpv4" arm_float_abi="hard" arm_use_neon=true build_static=true'
+            openwrt_release: '22.03.0'
+            openwrt_gcc_ver: '11.2.0'
           - arch: arm_cortex-a8_vfpv3
-            openwrt: 'target=sunxi subtarget=cortexa8'
+            openwrt: "target=sunxi subtarget=cortexa8"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="cortex-a8" arm_fpu="vfpv3" arm_float_abi="hard" arm_use_neon=false'
           - arch: arm_cortex-a9
-            openwrt: 'target=bcm53xx subtarget=generic'
+            openwrt: "target=bcm53xx subtarget=generic"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="cortex-a9" arm_float_abi="soft" arm_use_neon=false'
           - arch: arm_cortex-a9-static
-            openwrt: 'target=bcm53xx subtarget=generic'
+            openwrt: "target=bcm53xx subtarget=generic"
             target_cpu: arm
-            extra: 'arm_version=0 arm_cpu="cortex-a9" arm_float_abi="soft" arm_use_neon=false build_static=true'
+            extra: 'arm_version=0 arm_cpu="cortex-a9" arm_float_abi="soft" arm_use_neon=false build_static=true use_allocator_shim=false use_partition_alloc=false'
+            openwrt_release: '24.10.0'
+            openwrt_gcc_ver: '13.3.0'
           - arch: arm_cortex-a9_neon
-            openwrt: 'target=zynq'
+            openwrt: "target=imx6 subtarget=generic"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="cortex-a9" arm_fpu="neon" arm_float_abi="hard" arm_use_neon=true'
           - arch: arm_cortex-a9_vfpv3-d16
-            openwrt: 'target=tegra'
+            openwrt: "target=mvebu subtarget=cortexa9"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="cortex-a9" arm_fpu="vfpv3-d16" arm_float_abi="hard" arm_use_neon=false'
           - arch: arm_mpcore
-            openwrt: 'target=oxnas subtarget=ox820'
+            openwrt: "target=oxnas subtarget=ox820"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="mpcore" arm_float_abi="soft" arm_use_neon=false arm_use_thumb=false'
           - arch: arm_xscale
-            openwrt: 'target=kirkwood'
+            openwrt: "target=kirkwood subtarget=generic"
             target_cpu: arm
             extra: 'arm_version=0 arm_cpu="xscale" arm_float_abi="soft" arm_use_neon=false arm_use_thumb=false'
           - arch: mipsel_24kc
-            openwrt: 'target=ramips subtarget=rt305x'
+            openwrt: "target=ramips subtarget=rt305x"
             target_cpu: mipsel
             extra: 'mips_arch_variant="r2" mips_float_abi="soft"'
           - arch: mipsel_24kc-static
-            openwrt: 'target=ramips subtarget=rt305x'
+            openwrt: "target=ramips subtarget=rt305x"
             target_cpu: mipsel
-            extra: 'mips_arch_variant="r2" mips_float_abi="soft" build_static=true'
+            extra: 'mips_arch_variant="r2" mips_float_abi="soft" build_static=true use_allocator_shim=false use_partition_alloc=false'
+            openwrt_release: '24.10.0'
+            openwrt_gcc_ver: '13.3.0'
           - arch: mipsel_mips32
-            openwrt: 'target=bcm47xx subtarget=generic'
+            openwrt: "target=brcm47xx subtarget=legacy"
             target_cpu: mipsel
             extra: 'mips_arch_variant="r1" mips_float_abi="soft"'
+          - arch: riscv64
+            openwrt: "target=sifiveu subtarget=generic"
+            target_cpu: riscv64
+            openwrt_release: '23.05.0'
+            openwrt_gcc_ver: '12.3.0'
     env:
-      EXTRA_FLAGS: target_cpu="${{ matrix.target_cpu }}" target_os="openwrt" ${{ matrix.extra }}
-      OPENWRT_FLAGS: arch=${{ matrix.arch }} release=22.03.0 gcc_ver=11.2.0 ${{ matrix.openwrt }}
+      EXTRA_FLAGS: target_cpu="${{ matrix.target_cpu }}" target_os="openwrt" ${{ matrix.extra }} enable_shadow_metadata=false
+      OPENWRT_FLAGS: arch=${{ matrix.arch }} release=${{ matrix.openwrt_release || '18.06.0' }} gcc_ver=${{ matrix.openwrt_gcc_ver || '7.3.0' }} ${{ matrix.openwrt }}
       BUNDLE: naiveproxy-${{ github.event.release.tag_name }}-${{ github.job }}-${{ matrix.arch }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Cache toolchains (Linux, OpenWrt, Android)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             src/third_party/llvm-build/Release+Asserts/
@@ -495,29 +525,29 @@ jobs:
             src/qemu-user-static*.deb
           key: toolchains-posix-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache PGO (Linux, OpenWrt)
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: src/chrome/build/pgo_profiles/
           key: pgo-linux-openwrt-${{ hashFiles('CHROMIUM_VERSION') }}-v${{ env.CACHE_EPOCH }}
       - name: Cache sysroot
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: src/out/sysroot-build/openwrt
-          key: sysroot-openwrt-22.03.0-${{ matrix.arch }}-v${{ env.CACHE_EPOCH }}
+          key: sysroot-openwrt-23.05.0-${{ matrix.arch }}-v${{ env.CACHE_EPOCH }}
       - id: ccache-timestamp
         run: echo "CCACHE_TIMESTAMP=$(date +%s)" >>$GITHUB_OUTPUT
       - name: Cache ccache files
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
-          path: ~/.ccache
+          path: ~/.cache/ccache
           key: ccache-openwrt-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-${{ steps.ccache-timestamp.outputs.CCACHE_TIMESTAMP }}
           restore-keys: ccache-openwrt-${{ matrix.arch }}-${{ hashFiles('CHROMIUM_VERSION') }}-
       - name: Install APT packages
         run: |
           sudo apt update
-          sudo apt install ninja-build pkg-config qemu-user ccache bubblewrap
+          sudo apt install ninja-build pkg-config ccache bubblewrap
           sudo apt remove -y qemu-user-binfmt
-          sudo dpkg -i qemu-user-static_7.0+dfsg-6_amd64.deb
+          sudo dpkg -i qemu-user-static*.deb
           # libc6-i386 interferes with x86 build
           sudo apt remove libc6-i386
       - run: ./get-clang.sh
@@ -532,12 +562,12 @@ jobs:
           tar cJf ${{ env.BUNDLE }}.tar.xz ${{ env.BUNDLE }}
           openssl sha256 out/Release/naive >sha256sum.txt
           echo "SHA256SUM=$(cut -d' ' -f2 sha256sum.txt)" >>$GITHUB_ENV
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: ${{ env.BUNDLE }}.tar.xz naive executable sha256 ${{ env.SHA256SUM }}
           path: src/sha256sum.txt
       - name: Upload naiveproxy assets
         if: ${{ github.event_name == 'release' }}
-        run: hub release edit -a ${{ env.BUNDLE }}.tar.xz -m "" "${GITHUB_REF##*/}"
+        run: gh release upload "${GITHUB_REF##*/}" ${{ env.BUNDLE }}.tar.xz --clobber
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -2,7 +2,7 @@ src/chrome/android/profiles/afdo.prof
 src/chrome/build/pgo_profiles/
 src/gn/
 src/third_party/llvm-build/
-src/third_party/android_ndk/
+src/third_party/android_toolchain/
 src/out/
 .vscode/
 *.pyc

CHROMIUM_VERSION

@@ -1 +1 @@
-110.0.5481.100
+135.0.7049.38

README.md

@@ -21,7 +21,7 @@ The Naïve server here works as a forward proxy and a packet length padding laye
 
 ## Download NaïveProxy
 
-[Download here](https://github.com/klzgrad/naiveproxy/releases/latest). Supported platforms include: Windows, Android (with [SagerNet](https://github.com/SagerNet/SagerNet)), Linux, Mac OS, and OpenWrt ([support status](https://github.com/klzgrad/naiveproxy/wiki/OpenWrt-Support)).
+Download [here](https://github.com/klzgrad/naiveproxy/releases/latest). Supported platforms include: Windows, Android (with [Exclave](https://github.com/dyhkwong/Exclave), [NekoBox](https://github.com/MatsuriDayo/NekoBoxForAndroid)), Linux, Mac OS, and OpenWrt ([support status](https://github.com/klzgrad/naiveproxy/wiki/OpenWrt-Support)).
 
 Users should always use the latest version to keep signatures identical to Chrome.
 
@@ -29,12 +29,12 @@ Build from source: Please see [.github/workflows/build.yml](https://github.com/k
 
 ## Server setup
 
-The following describes the naïve fork of forwardproxy setup.
+The following describes the naïve fork of Caddy forwardproxy setup.
 
-Build:
+Download [here](https://github.com/klzgrad/forwardproxy/releases/latest) or build from source:
 ```sh
 go install github.com/caddyserver/xcaddy/cmd/xcaddy@latest
-~/go/bin/xcaddy build --with github.com/caddyserver/forwardproxy@caddy2=github.com/klzgrad/forwardproxy@naive
+~/go/bin/xcaddy build --with github.com/caddyserver/forwardproxy=github.com/klzgrad/forwardproxy@naive
 ```
 
 Example Caddyfile (replace `user` and `pass` accordingly):
@@ -55,7 +55,7 @@ Example Caddyfile (replace `user` and `pass` accordingly):
   }
 }
 ```
-`:443` must appear first for this Caddyfile to work. For more advanced usage consider using [JSON for Caddy 2's config](https://caddyserver.com/docs/json/).
+`:443` must appear first for this Caddyfile to work. See Caddyfile [docs](https://caddyserver.com/docs/caddyfile/directives/tls) for customizing TLS certificates. For more advanced usage consider using [JSON for Caddy 2's config](https://caddyserver.com/docs/json/).
 
 Run with the Caddyfile:
 ```
@@ -77,6 +77,12 @@ Run `./naive` with the following `config.json` to get a SOCKS5 proxy at local po
 
 Or `quic://user:pass@example.com`, if it works better. See also [parameter usage](https://github.com/klzgrad/naiveproxy/blob/master/USAGE.txt) and [performance tuning](https://github.com/klzgrad/naiveproxy/wiki/Performance-Tuning).
 
+## Third-party integration
+
+* [v2rayN](https://github.com/2dust/v2rayN), GUI client, Windows
+* [NekoBox for Android](https://github.com/MatsuriDayo/NekoBoxForAndroid), Proxy toolchain, Android
+* [NekoRay / NekoBox For PC](https://github.com/MatsuriDayo/nekoray), Qt based GUI, Windows, Linux
+
 ## Notes for downstream
 
 Do not use the master branch to track updates, as it rebases from a new root commit for every new Chrome release. Use stable releases and the associated tags to track new versions, where short release notes are also provided.
@@ -107,7 +113,7 @@ Further reads and writes after `kFirstPaddings` are unpadded to avoid performanc
 
 ### H2 RST_STREAM frame padding
 
-In experiments, NaïveProxy tends to send too many RST_STREAM frames per session, an uncommon behavior from regular browsers. To solve this, an END_STREAM DATA frame padded with total length distributed in [48, 72] is prepended to the RST_STREAM frame so it looks like a HEADERS frame. The server often replies to this with a WINDOW_UPDATE because padding is accounted in flow control. Whether this results in a new uncommon behavior is still unclear. 
+In experiments, NaïveProxy tends to send too many RST_STREAM frames per session, an uncommon behavior from regular browsers. To solve this, an END_STREAM DATA frame padded with total length distributed in [48, 72] is prepended to the RST_STREAM frame so it looks like a HEADERS frame. The server often replies to this with a WINDOW_UPDATE because padding is accounted in flow control. Whether this results in a new uncommon behavior is still unclear.
 
 ### H2 HEADERS frame padding
 
@@ -121,9 +127,9 @@ NaïveProxy servers and clients determines whether the counterpart is capable of
 
 The first CONNECT request to a server cannot use "Fast Open" to send payload before response, because the server's padding capability has not been determined from the first response and it's unknown whether to send padded or unpadded payload for Fast Open.
 
-## Changes from upstream
+## Changes from Chromium upstream
 
-- Minimize source code and build size (1% of the original)
+- Minimize source code and build size (0.3% of the original)
 - Disable exceptions and RTTI, except on Mac and Android.
 - Support OpenWrt builds
 - (Android, Linux) Use the builtin verifier instead of the system verifier (drop dependency of NSS on Linux) and read the system trust store from (following Go's behavior in crypto/x509/root_unix.go and crypto/x509/root_linux.go):
@@ -154,3 +160,4 @@ The first CONNECT request to a server cannot use "Fast Open" to send payload bef
 * TLS over TLS overhead also causes packets to consistently exceed MTU limits, which should not happen for an originating user agent. Fixing this requires re-segmentation and it is not easy to do.
 * Packet length obfuscation partly relies on h2 multiplexing, which does not work if there is only one connection, a scenario not uncommon. It is not clear how to create covering co-connections organically (i.e. not hard coded).
 * Multiplexing requires use of a few long-lived tunnel connections. It is not clearly how long is appropriate for parroting and how to convincingly rotate the connections if there is an age limit or how to detect and recover stuck tunnel connections convincingly.
+

USAGE.txt

@@ -14,6 +14,9 @@ Description:
       "proxy": "..."
     }
 
+  Specifying a flag multiple times on the command line is equivalent to
+  having an array of multiple strings in the JSON file.
+
   Uses "config.json" by default if run without arguments.
 
 Options:
@@ -26,17 +29,16 @@ Options:
 
     Prints version.
 
-  --listen=<proto>://[addr][:port]
-  --listen=socks://[[user]:[pass]@][addr][:port]
+  --listen=LISTEN-URI
 
-    Listens at addr:port with protocol <proto>.
+    LISTEN-URI = <LISTEN-PROTO>"://"[<USER>":"<PASS>"@"][<ADDR>][":"<PORT>]
+    LISTEN-PROTO = "socks" | "http" | "redir"
 
-    Available proto: socks, http, redir.
+    Listens at addr:port with protocol <LISTEN-PROTO>.
+    Can be specified multiple times to listen on multiple ports.
     Default proto, addr, port: socks, 0.0.0.0, 1080.
 
-    * http: Supports only proxying https:// URLs, no http://.
-
-    * redir: Works with certain iptables setup.
+    Note: redir requires specific iptables rules and uses no authentication.
 
       (Redirecting locally originated traffic)
       iptables -t nat -A OUTPUT -d $proxy_server_ip -j RETURN
@@ -53,10 +55,21 @@ Options:
       The artificial results are not saved for privacy, so restarting the
       resolver may cause downstream to cache stale results.
 
-  --proxy=<proto>://<user>:<pass>@<hostname>[:<port>]
+  --proxy=PROXY
 
-    Routes traffic via the proxy server. Connects directly by default.
-    Available proto: https, quic. Infers port by default.
+    PROXY = PROXY-CHAIN | SOCKS-PROXY
+    PROXY-CHAIN = <PROXY-URI>[","<PROXY-CHAIN>] 
+    PROXY-URI = <PROXY-PROTO>"://"[<USER>":"<PASS>"@"]<HOSTNAME>[":"<PORT>]
+    PROXY-PROTO = "http" | "https" | "quic"
+    SOCKS-PROXY = "socks://"<HOSTNAME>[":"<PORT>]
+
+    Routes traffic via the proxy chain.
+    The default proxy is directly connection without proxying.
+    The last PROXY-URI is negotiated automatically for Naive padding.
+    Limitations:
+      * QUIC proxies cannot follow TCP-based proxies in a proxy chain.
+      * The user needs to ensure there is no loop in the proxy chain.
+      * SOCKS proxies do not support chaining, authentication, or Naive padding.
 
   --insecure-concurrency=<N>
 
@@ -93,3 +106,7 @@ Options:
   --ssl-key-log-file=<path>
 
     Saves SSL keys for Wireshark inspection.
+
+  --no-post-quantum
+
+    Overrides the default and disables post-quantum key agreement.

apk/.gitignore

@@ -0,0 +1,3 @@
+.gradle/
+app/build/
+app/libs/

apk/app/build.gradle.kts

@@ -0,0 +1,73 @@
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+}
+
+android {
+    namespace = "io.nekohasekai.sagernet.plugin.naive"
+
+    signingConfigs {
+        create("release") {
+            storeFile = rootProject.file("release.keystore")
+            storePassword = System.getenv("KEYSTORE_PASS")
+            keyAlias = "release"
+            keyPassword = System.getenv("KEYSTORE_PASS")
+        }
+    }
+
+    buildTypes {
+        getByName("release") {
+            isMinifyEnabled = true
+            signingConfig = signingConfigs.getByName("release")
+        }
+    }
+
+    buildToolsVersion = "35.0.0"
+
+    compileSdk = 35
+
+    defaultConfig {
+        minSdk = 24
+        targetSdk = 35
+
+        applicationId = "io.nekohasekai.sagernet.plugin.naive"
+        versionCode = System.getenv("APK_VERSION_NAME").removePrefix("v").split(".")[0].toInt() * 10 + System.getenv("APK_VERSION_NAME").removePrefix("v").split("-")[1].toInt()
+        versionName = System.getenv("APK_VERSION_NAME").removePrefix("v")
+        splits.abi {
+            isEnable = true
+            isUniversalApk = false
+            reset()
+            include(System.getenv("APK_ABI"))
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    lint {
+        showAll = true
+        checkAllWarnings = true
+        checkReleaseBuilds = false
+        warningsAsErrors = true
+    }
+
+    packaging {
+        jniLibs.useLegacyPackaging = true
+    }
+
+    applicationVariants.all {
+        outputs.all {
+            this as com.android.build.gradle.internal.api.BaseVariantOutputImpl
+            outputFileName =
+                outputFileName.replace(project.name, "naiveproxy-plugin-v$versionName")
+                    .replace("-release", "")
+                    .replace("-oss", "")
+        }
+    }
+
+    sourceSets.getByName("main") {
+        jniLibs.srcDir("libs")
+    }
+}

apk/app/src/main/AndroidManifest.xml

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:installLocation="internalOnly"
+    tools:ignore="MissingLeanbackLauncher">
+
+    <uses-feature
+        android:name="android.software.leanback"
+        android:required="false" />
+    <uses-feature
+        android:name="android.hardware.touchscreen"
+        android:required="false" />
+
+    <application
+        android:allowBackup="false"
+        android:icon="@mipmap/ic_launcher"
+        android:label="Naïve Plugin"
+        android:roundIcon="@mipmap/ic_launcher_round">
+        <provider
+            android:name=".BinaryProvider"
+            android:authorities="io.nekohasekai.sagernet.plugin.naive.BinaryProvider"
+            android:directBootAware="true"
+            android:exported="true"
+            tools:ignore="ExportedContentProvider">
+            <intent-filter>
+                <action android:name="io.nekohasekai.sagernet.plugin.ACTION_NATIVE_PLUGIN" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="io.nekohasekai.sagernet.plugin.ACTION_NATIVE_PLUGIN" />
+                <data
+                    android:host="io.nekohasekai.sagernet"
+                    android:path="/naive-plugin"
+                    android:scheme="plugin" />
+            </intent-filter>
+
+            <meta-data
+                android:name="io.nekohasekai.sagernet.plugin.id"
+                android:value="naive-plugin" />
+            <meta-data
+                android:name="io.nekohasekai.sagernet.plugin.executable_path"
+                android:value="libnaive.so" />
+        </provider>
+    </application>
+
+</manifest>

apk/app/src/main/java/io/nekohasekai/sagernet/plugin/NativePluginProvider.kt

@@ -0,0 +1,98 @@
+/******************************************************************************
+ *                                                                            *
+ * Copyright (C) 2021 by nekohasekai <contact-sagernet@sekai.icu>             *
+ *                                                                            *
+ * This program is free software: you can redistribute it and/or modify       *
+ * it under the terms of the GNU General Public License as published by       *
+ * the Free Software Foundation, either version 3 of the License, or          *
+ *  (at your option) any later version.                                       *
+ *                                                                            *
+ * This program is distributed in the hope that it will be useful,            *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
+ * GNU General Public License for more details.                               *
+ *                                                                            *
+ * You should have received a copy of the GNU General Public License          *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.       *
+ *                                                                            *
+ ******************************************************************************/
+
+package io.nekohasekai.sagernet.plugin
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.database.Cursor
+import android.database.MatrixCursor
+import android.net.Uri
+import android.os.Bundle
+import android.os.ParcelFileDescriptor
+
+abstract class NativePluginProvider : ContentProvider() {
+    override fun getType(uri: Uri): String? = "application/x-elf"
+
+    override fun onCreate(): Boolean = true
+
+    /**
+     * Provide all files needed for native plugin.
+     *
+     * @param provider A helper object to use to add files.
+     */
+    protected abstract fun populateFiles(provider: PathProvider)
+
+    override fun query(
+        uri: Uri,
+        projection: Array<out String>?,
+        selection: String?,
+        selectionArgs: Array<out String>?,
+        sortOrder: String?,
+    ): Cursor? {
+        check(selection == null && selectionArgs == null && sortOrder == null)
+        val result = MatrixCursor(projection)
+        populateFiles(PathProvider(uri, result))
+        return result
+    }
+
+    /**
+     * Returns executable entry absolute path.
+     * This is used for fast mode initialization where ss-local launches your native binary at the path given directly.
+     * In order for this to work, plugin app is encouraged to have the following in its AndroidManifest.xml:
+     *  - android:installLocation="internalOnly" for <manifest>
+     *  - android:extractNativeLibs="true" for <application>
+     *
+     * Default behavior is throwing UnsupportedOperationException. If you don't wish to use this feature, use the
+     * default behavior.
+     *
+     * @return Absolute path for executable entry.
+     */
+    open fun getExecutable(): String = throw UnsupportedOperationException()
+
+    abstract fun openFile(uri: Uri): ParcelFileDescriptor
+    override fun openFile(uri: Uri, mode: String): ParcelFileDescriptor {
+        check(mode == "r")
+        return openFile(uri)
+    }
+
+    override fun call(method: String, arg: String?, extras: Bundle?): Bundle? = when (method) {
+        PluginContract.METHOD_GET_EXECUTABLE -> {
+            Bundle().apply {
+                putString(PluginContract.EXTRA_ENTRY, getExecutable())
+            }
+        }
+        else -> super.call(method, arg, extras)
+    }
+
+    // Methods that should not be used
+    override fun insert(uri: Uri, values: ContentValues?): Uri? =
+        throw UnsupportedOperationException()
+
+    override fun update(
+        uri: Uri,
+        values: ContentValues?,
+        selection: String?,
+        selectionArgs: Array<out String>?,
+    ): Int =
+        throw UnsupportedOperationException()
+
+    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int =
+        throw UnsupportedOperationException()
+}

apk/app/src/main/java/io/nekohasekai/sagernet/plugin/PathProvider.kt

@@ -0,0 +1,53 @@
+/******************************************************************************
+ *                                                                            *
+ * Copyright (C) 2021 by nekohasekai <contact-sagernet@sekai.icu>             *
+ *                                                                            *
+ * This program is free software: you can redistribute it and/or modify       *
+ * it under the terms of the GNU General Public License as published by       *
+ * the Free Software Foundation, either version 3 of the License, or          *
+ *  (at your option) any later version.                                       *
+ *                                                                            *
+ * This program is distributed in the hope that it will be useful,            *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
+ * GNU General Public License for more details.                               *
+ *                                                                            *
+ * You should have received a copy of the GNU General Public License          *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.       *
+ *                                                                            *
+ ******************************************************************************/
+
+package io.nekohasekai.sagernet.plugin
+
+import android.database.MatrixCursor
+import android.net.Uri
+import java.io.File
+
+/**
+ * Helper class to provide relative paths of files to copy.
+ */
+class PathProvider internal constructor(baseUri: Uri, private val cursor: MatrixCursor) {
+    private val basePath = baseUri.path?.trim('/') ?: ""
+
+    fun addPath(path: String, mode: Int = 0b110100100): PathProvider {
+        val trimmed = path.trim('/')
+        if (trimmed.startsWith(basePath)) cursor.newRow()
+                .add(PluginContract.COLUMN_PATH, trimmed)
+                .add(PluginContract.COLUMN_MODE, mode)
+        return this
+    }
+    fun addTo(file: File, to: String = "", mode: Int = 0b110100100): PathProvider {
+        var sub = to + file.name
+        if (basePath.startsWith(sub)) if (file.isDirectory) {
+            sub += '/'
+            file.listFiles()!!.forEach { addTo(it, sub, mode) }
+        } else addPath(sub, mode)
+        return this
+    }
+    fun addAt(file: File, at: String = "", mode: Int = 0b110100100): PathProvider {
+        if (basePath.startsWith(at)) {
+            if (file.isDirectory) file.listFiles()!!.forEach { addTo(it, at, mode) } else addPath(at, mode)
+        }
+        return this
+    }
+}

apk/app/src/main/java/io/nekohasekai/sagernet/plugin/PluginContract.kt

@@ -0,0 +1,34 @@
+/******************************************************************************
+ *                                                                            *
+ * Copyright (C) 2021 by nekohasekai <contact-sagernet@sekai.icu>             *
+ *                                                                            *
+ * This program is free software: you can redistribute it and/or modify       *
+ * it under the terms of the GNU General Public License as published by       *
+ * the Free Software Foundation, either version 3 of the License, or          *
+ *  (at your option) any later version.                                       *
+ *                                                                            *
+ * This program is distributed in the hope that it will be useful,            *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
+ * GNU General Public License for more details.                               *
+ *                                                                            *
+ * You should have received a copy of the GNU General Public License          *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.       *
+ *                                                                            *
+ ******************************************************************************/
+
+package io.nekohasekai.sagernet.plugin
+
+object PluginContract {
+
+    const val ACTION_NATIVE_PLUGIN = "io.nekohasekai.sagernet.plugin.ACTION_NATIVE_PLUGIN"
+    const val EXTRA_ENTRY = "io.nekohasekai.sagernet.plugin.EXTRA_ENTRY"
+    const val METADATA_KEY_ID = "io.nekohasekai.sagernet.plugin.id"
+    const val METADATA_KEY_EXECUTABLE_PATH = "io.nekohasekai.sagernet.plguin.executable_path"
+    const val METHOD_GET_EXECUTABLE = "sagernet:getExecutable"
+
+    const val COLUMN_PATH = "path"
+    const val COLUMN_MODE = "mode"
+    const val SCHEME = "plugin"
+    const val AUTHORITY = "io.nekohasekai.sagernet"
+}

apk/app/src/main/java/io/nekohasekai/sagernet/plugin/naive/BinaryProvider.kt

@@ -0,0 +1,42 @@
+/******************************************************************************
+ *                                                                            *
+ * Copyright (C) 2021 by nekohasekai <contact-sagernet@sekai.icu>             *
+ *                                                                            *
+ * This program is free software: you can redistribute it and/or modify       *
+ * it under the terms of the GNU General Public License as published by       *
+ * the Free Software Foundation, either version 3 of the License, or          *
+ *  (at your option) any later version.                                       *
+ *                                                                            *
+ * This program is distributed in the hope that it will be useful,            *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
+ * GNU General Public License for more details.                               *
+ *                                                                            *
+ * You should have received a copy of the GNU General Public License          *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.       *
+ *                                                                            *
+ ******************************************************************************/
+
+package io.nekohasekai.sagernet.plugin.naive
+
+import android.net.Uri
+import android.os.ParcelFileDescriptor
+import io.nekohasekai.sagernet.plugin.NativePluginProvider
+import io.nekohasekai.sagernet.plugin.PathProvider
+import java.io.File
+import java.io.FileNotFoundException
+
+class BinaryProvider : NativePluginProvider() {
+    override fun populateFiles(provider: PathProvider) {
+        provider.addPath("naive-plugin", 0b111101101)
+    }
+
+    override fun getExecutable() = context!!.applicationInfo.nativeLibraryDir + "/libnaive.so"
+    override fun openFile(uri: Uri): ParcelFileDescriptor = when (uri.path) {
+        "/naive-plugin" -> ParcelFileDescriptor.open(
+            File(getExecutable()),
+            ParcelFileDescriptor.MODE_READ_ONLY
+        )
+        else -> throw FileNotFoundException()
+    }
+}

apk/app/src/main/res/drawable/ic_launcher_foreground.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108"
+    android:tint="#FFFFFF">
+  <group android:scaleX="0.13877095"
+      android:scaleY="0.13877095"
+      android:translateX="29.16"
+      android:translateY="42.010185">
+    <group android:translateY="138.67206">
+      <path android:pathData="M4.171875,-0L34.546875,-0L34.546875,-5.890625L25.90625,-7.046875L23.3125,-9.796875L23.3125,-82.125L78.1875,-0L87.6875,-0L87.6875,-87.328125L90.28125,-89.9375L98.921875,-91.234375L98.921875,-97L68.671875,-97L68.671875,-91.234375L77.3125,-89.9375L79.90625,-87.328125L79.90625,-19.34375L30.8125,-93.390625L30.8125,-97L3.734375,-97L3.734375,-91.234375L12.953125,-90.359375L15.546875,-88.34375L15.546875,-9.796875L12.953125,-7.046875L4.171875,-5.890625L4.171875,-0Z"
+          android:fillColor="#FFFFFF"/>
+      <path android:pathData="M151.09375,-8.375L152.95312,0L173.26562,0L173.26562,-5.171875L165.625,-5.90625L163.03125,-8.234375L163.03125,-50.3125C163.03125,-64.796875,156.70312,-71,141.57812,-71C123.4375,-71,112.5,-63.5,112.5,-54.75C112.5,-51.3125,113.640625,-50.3125,116.953125,-50.3125L126.890625,-50.3125L126.890625,-62.359375C130.78125,-63.9375,134.23438,-64.65625,137.84375,-64.65625C148.20312,-64.65625,151.09375,-59.921875,151.09375,-48.578125L151.09375,-44C122.28125,-37.0625,109.046875,-32.6875,109.046875,-17.546875C109.046875,-6.625,116.09375,1,127.46875,1C134.39062,1.015625,142.01562,-2.15625,151.09375,-8.375ZM151.09375,-13.328125C143.89062,-9.09375,137.98438,-6.765625,133.23438,-6.765625C126.03125,-6.765625,121.71875,-11.578125,121.71875,-18.703125C121.71875,-29.34375,130.78125,-33.265625,151.09375,-38.953125L151.09375,-13.328125Z"
+          android:fillColor="#FFFFFF"/>
+      <path android:pathData="M197.59375,-70L181.03125,-65L181.03125,-60.53125L191.10938,-60.53125L191.10938,-8.203125L188.65625,-5.90625L181.03125,-5.171875L181.03125,0L213.4375,0L213.4375,-5.171875L205.65625,-5.90625L203.20312,-8.203125L203.20312,-70L197.59375,-70ZM182.76562,-99.53125C178.73438,-99.53125,175.42188,-96.375,175.42188,-92.1875C175.42188,-88.15625,178.73438,-85,182.76562,-85C186.79688,-85,189.95312,-88.15625,189.95312,-92.1875C189.95312,-96.375,186.79688,-99.53125,182.76562,-99.53125ZM209.54688,-99.53125C205.51562,-99.53125,202.20312,-96.375,202.20312,-92.1875C202.20312,-88.15625,205.51562,-85,209.54688,-85C213.57812,-85,216.75,-88.15625,216.75,-92.1875C216.75,-96.375,213.57812,-99.53125,209.54688,-99.53125Z"
+          android:fillColor="#FFFFFF"/>
+      <path android:pathData="M215.26562,-69L215.26562,-63.671875L224.0625,-62.796875L247.23438,0L255.29688,0L280.5,-62.515625L289,-63.671875L289,-69L263.51562,-69L263.51562,-63.671875L271.28125,-63.09375L272.4375,-60.796875L254,-13.90625L237.15625,-60.796875L238.89062,-63.09375L246.51562,-63.671875L246.51562,-69L215.26562,-69Z"
+          android:fillColor="#FFFFFF"/>
+      <path android:pathData="M351.5,-15.5C343.29688,-10.0625,336.09375,-7.203125,328.89062,-7.203125C314.35938,-7.203125,304.70312,-18.078125,304.70312,-36.421875C304.70312,-36.84375,304.70312,-37.421875,304.70312,-38L351.35938,-38C351.5,-39.578125,351.5,-41.015625,351.5,-42.453125C351.5,-60.296875,341.28125,-71,325.57812,-71C306.28125,-71,292.3125,-56.09375,292.3125,-34.265625C292.3125,-13.21875,305.42188,1,324.4375,1C333.5,1,342.85938,-1.875,351.5,-7.625L351.5,-15.5ZM338.6875,-44.046875L305.42188,-44.046875C306.28125,-56.375,314.5,-64.515625,323.71875,-64.515625C333.35938,-64.515625,338.6875,-58.125,338.6875,-46.359375C338.6875,-45.640625,338.6875,-44.765625,338.6875,-44.046875Z"
+          android:fillColor="#FFFFFF"/>
+    </group>
+  </group>
+</vector>

apk/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+    <monochrome android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>

apk/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+    <monochrome android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>

apk/app/src/main/res/values/ic_launcher_background.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">#E91E63</color>
+</resources>

apk/build.gradle

@@ -0,0 +1,18 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.6.0'
+        classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:2.0.20'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}

apk/gradle.properties

@@ -0,0 +1,21 @@
+# Project-wide Gradle settings.
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+# AndroidX package structure to make it clearer which packages are bundled with the
+# Android operating system, and which are packaged with your app"s APK
+# https://developer.android.com/topic/libraries/support-library/androidx-rn
+android.useAndroidX=true
+# Automatically convert third-party libraries to use AndroidX
+android.enableJetifier=true
+# Kotlin code style for this project: "official" or "obsolete":
+kotlin.code.style=official

apk/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

apk/gradlew

@@ -0,0 +1,252 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# 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
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

apk/gradlew.bat

@@ -0,0 +1,94 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

apk/settings.gradle

@@ -0,0 +1,10 @@
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+rootProject.name = "Naive Plugin"
+
+include ':app'

src/.clang-format

@@ -10,6 +10,47 @@ Standard: Cpp11
 # TODO(crbug.com/1392808): Remove when InsertBraces has been upstreamed into
 # the Chromium style (is implied by BasedOnStyle: Chromium).
 InsertBraces: true
+InsertNewlineAtEOF: true
+
+# Sort #includes by following
+# https://google.github.io/styleguide/cppguide.html#Names_and_Order_of_Includes
+#
+# ref: https://clang.llvm.org/docs/ClangFormatStyleOptions.html#includeblocks
+IncludeBlocks: Regroup
+# ref: https://clang.llvm.org/docs/ClangFormatStyleOptions.html#includecategories
+IncludeCategories:
+  # The win32 api has all sorts of implicit include order dependencies :-/
+  # Give a few headers special priorities that make sure they appear before
+  # all other headers.
+  # Sync this with SerializeIncludes in tools/add_header.py.
+  # TODO(crbug.com/329138753): remove include sorting from tools/add_header.py
+  # after confirming clang-format sort works well.
+  # LINT.IfChange(winheader)
+  - Regex:           '^<objbase\.h>' # This has to be before initguid.h.
+    Priority:        1
+  - Regex:           '^<(atlbase|initguid|mmdeviceapi|ocidl|ole2|shobjidl|tchar|unknwn|windows|winsock2|winternl|ws2tcpip)\.h>'
+    Priority:        2
+  # LINT.ThenChange(/tools/add_header.py:winheader)
+  # UIAutomation*.h needs to be after base/win/atl.h.
+  # Note the low priority number.
+  - Regex:           '^<UIAutomation.*\.h>'
+    Priority:        6
+  # Other C system headers.
+  - Regex:           '^<.*\.h>'
+    Priority:        3
+  # C++ standard library headers.
+  - Regex:           '^<.*>'
+    Priority:        4
+  # windows_h_disallowed.h should appear last. Note the low priority number.
+  - Regex:           '"(.*/)?windows_h_disallowed\.h"'
+    Priority:        7
+  # Other libraries.
+  - Regex:           '.*'
+    Priority:        5
+# ref: https://clang.llvm.org/docs/ClangFormatStyleOptions.html#includeismainregex
+IncludeIsMainRegex: "\
+(_(32|64|android|apple|chromeos|freebsd|fuchsia|fuzzer|ios|linux|mac|nacl|openbsd|posix|stubs?|win))?\
+(_(unit|browser|perf)?tests?)?$"
 
 # Make sure code like:
 # IPC_BEGIN_MESSAGE_MAP()
@@ -38,6 +79,3 @@ IPC_STRUCT_END|\
 IPC_STRUCT_TRAITS_END|\
 POLPARAMS_END|\
 PPAPI_END_MESSAGE_MAP$"
-
-# TODO: Remove this once clang-format r357700 is rolled in.
-JavaImportGroups: ['android', 'androidx', 'com', 'dalvik', 'junit', 'org', 'com.google.android.apps.chrome', 'org.chromium', 'java', 'javax']

src/.gitattributes

@@ -30,6 +30,7 @@
 *.proto text eol=lf
 *.rs text eol=lf
 *.sh text eol=lf
+*.spec text eol=lf
 *.sql   text eol=lf
 *.toml  text eol=lf
 *.txt   text eol=lf

src/.gn

@@ -39,6 +39,12 @@ default_args = {
   # Don't include webrtc's builtin task queue implementation.
   rtc_link_task_queue_impl = false
 
+  # When building with Chromium, `webrtc::Location` is replaced by
+  # `base::Location`. Since WebRTC doesn't use `public_deps` (webrtc:8603), it
+  # would fail to propagate the dependency internally. Instead WebRTC let its
+  # embedders to define it globally for all of its targets.
+  rtc_common_public_deps = [ "//base" ]
+
   # Don't include the iLBC audio codec.
   # TODO(bugs.webrtc.org/8396): Once WebRTC gets rid of its internal
   # deps on codecs, we can remove this.
@@ -49,18 +55,25 @@ default_args = {
   crashpad_dependencies = "chromium"
 
   # Override ANGLE's Vulkan dependencies.
-  angle_vulkan_headers_dir = "//third_party/vulkan-deps/vulkan-headers/src"
-  angle_vulkan_loader_dir = "//third_party/vulkan-deps/vulkan-loader/src"
-  angle_vulkan_tools_dir = "//third_party/vulkan-deps/vulkan-tools/src"
+  angle_vulkan_headers_dir = "//third_party/vulkan-headers/src"
+  angle_vulkan_loader_dir = "//third_party/vulkan-loader/src"
+  angle_vulkan_tools_dir = "//third_party/vulkan-tools/src"
   angle_vulkan_validation_layers_dir =
-      "//third_party/vulkan-deps/vulkan-validation-layers/src"
+      "//third_party/vulkan-validation-layers/src"
+
+  # Override VMA's Vulkan dependencies.
+  vma_vulkan_headers_dir = "//third_party/vulkan-headers/src"
 
   # Overwrite default args declared in the Fuchsia sdk
   fuchsia_sdk_readelf_exec =
       "//third_party/llvm-build/Release+Asserts/bin/llvm-readelf"
-  fuchsia_target_api_level = 10
+
+  # Overwrite default args declared in the pdfium library
+  pdf_partition_alloc_dir = "//base/allocator/partition_allocator"
 
   devtools_visibility = [ "*" ]
+
+  clang_unsafe_buffers_paths = "//build/config/unsafe_buffers_paths.txt"
 }
 
 # These are the targets to skip header checking by default. The files in targets
@@ -68,10 +81,6 @@ default_args = {
 # their includes checked for proper dependencies when you run either
 # "gn check" or "gn gen --check".
 no_check_targets = [
-  # crbug.com/1158989
-  "//headless:headless_renderer",  # 12 errors
-  "//headless:headless_shared_sources",  # 2 errors
-
   # //v8, https://crbug.com/v8/7330
   "//v8/src/inspector:inspector",  # 20 errors
   "//v8/test/cctest:cctest_sources",  # 15 errors
@@ -79,15 +88,9 @@ no_check_targets = [
   "//v8:cppgc_base",  # 1 error
   "//v8:v8_internal_headers",  # 11 errors
   "//v8:v8_libplatform",  # 2 errors
-
-  # After making partition_alloc a standalone library, remove partition_alloc
-  # target from the skip list, because partition_aloc will depend on its own
-  # base.
-  # partition alloc standalone library bug is https://crbug.com/1151236.
-  "//base/allocator/partition_allocator:partition_alloc",  # 292 errors
 ]
 
-# These are the list of GN files that run exec_script. This whitelist exists
+# These are the list of GN files that run exec_script. This allowlist exists
 # to force additional review for new uses of exec_script, which is strongly
 # discouraged.
 #
@@ -142,11 +145,11 @@ no_check_targets = [
 #      this situation much easier to create. if the build always lists the
 #      files and passes them to a script, it will always be correct.
 
-exec_script_whitelist =
-    build_dotfile_settings.exec_script_whitelist +
+exec_script_allowlist =
+    build_dotfile_settings.exec_script_allowlist +
     angle_dotfile_settings.exec_script_whitelist +
     [
-      # Whitelist entries for //build should go into
+      # Allowlist entries for //build should go into
       # //build/dotfile_settings.gni instead, so that they can be shared
       # with other repos. The entries in this list should be only for files
       # in the Chromium repo outside of //build.

src/BUILD.gn

@@ -9,6 +9,7 @@
 # file to your new one or GN won't know about it.
 
 import("//build/config/compiler/compiler.gni")
+import("//build/config/cronet/config.gni")
 import("//build/config/dcheck_always_on.gni")
 import("//build/config/features.gni")
 import("//build/config/rust.gni")
@@ -33,38 +34,25 @@ if (is_official_build) {
   assert(!is_component_build)
 }
 
-# This file defines the following two main targets:
+# The `gn_all` target is used to list all of the main targets in the build, so
+# that we can figure out which BUILD.gn files to process, following the process
+# described at the top of this file.
 #
-# "gn_all" is used to create explicit dependencies from the root BUILD.gn to
-# each top-level component that we wish to include when building everything via
-# "all". This is required since the set of targets built by "all" is determined
-# automatically based on reachability from the root BUILD.gn (for details, see
-# crbug.com/503241). Builders should typically use "all", or list targets
-# explicitly, rather than relying on "gn_all".
-#
-# "gn_visibility": targets that are normally not visible to top-level targets,
-# but are built anyway by "all". Since we don't want any such targets, we have
-# this placeholder to make sure hidden targets that aren't otherwise depended
-# on yet are accounted for.
+# Because of the way GN works (again, as described above), there may be targets
+# built by `all` that aren't built by `gn_all`. We always want `all` to build,
+# so there's really never a reason you'd want to build `gn_all` instead of
+# `all`, and no tooling should depend directly on this target. Tools should
+# should depend on either an explicit list of targets, or `all`.
 
 group("gn_all") {
   testonly = true
 
   deps = [
-    ":gn_visibility",
     "//net",
   ]
 }
 
-group("gn_visibility") {
-  deps = [
-    "//build/config/sanitizers:options_sources",
-    # "//third_party/pdfium:pdfium_embeddertests",  # TODO(GYP): visibility?
-    # "//third_party/pdfium:pdfium_unittests",  # TODO(GYP): visibility?
-  ]
-}
-
-if (is_android) {
+if (is_android && !is_cronet_build) {
   group("optimize_gn_gen") {
     deps = [
       # These run expensive scripts in non-default toolchains. Generally, host

src/base/DEPS

@@ -3,7 +3,10 @@ include_rules = [
   "+third_party/apple_apsl",
   "+third_party/boringssl/src/include",
   "+third_party/ced",
-  "+third_party/libevent",
+  "+third_party/fuzztest",
+  # We are moving the old jni_generator to jni_zero, some references will remain
+  # in //base.
+  "+third_party/jni_zero",
   "+third_party/libunwindstack/src/libunwindstack/include",
   "+third_party/lss",
   "+third_party/modp_b64",
@@ -16,7 +19,8 @@ include_rules = [
   "+third_party/rust/cxx",
   "+third_party/test_fonts",
   # JSON Deserialization.
-  "+third_party/rust/serde_json_lenient/v0_1/wrapper",
+  "+third_party/rust/serde_json_lenient/v0_2/wrapper",
+  "+third_party/zlib",
 
   # These are implicitly brought in from the root, and we don't want them.
   "-ipc",
@@ -34,4 +38,8 @@ specific_include_rules = {
   "process/current_process(|_test)\.h": [
     "+third_party/perfetto/protos/perfetto/trace/track_event/chrome_process_descriptor.pbzero.h",
   ],
-}
+  # To evaluate the performance effects of using absl's flat_hash_map.
+  "supports_user_data\.cc": [
+    "+third_party/abseil-cpp/absl/container/flat_hash_map.h",
+  ]
+}

src/base/DIR_METADATA

@@ -1,3 +1,6 @@
-monorail {
+monorail: {
   component: "Internals>Core"
 }
+buganizer_public: {
+  component_id: 1456128
+}

src/base/OWNERS

@@ -1,19 +1,19 @@
 # See //base/README.md to find qualification for being an owner.
 
 set noparent
-# NOTE: keep this in sync with lsc-owners-override@chromium.org owners
+# NOTE: keep this in sync with global-owners-override@chromium.org owners
 # by emailing lsc-policy@chromium.org when this list changes.
 altimin@chromium.org
-danakj@chromium.org
 dcheng@chromium.org
 fdoray@chromium.org
 gab@chromium.org
 kylechar@chromium.org
 mark@chromium.org
+pkasting@chromium.org
 thakis@chromium.org
 thestig@chromium.org
 wez@chromium.org
-# NOTE: keep this in sync with lsc-owners-override@chromium.org owners
+# NOTE: keep this in sync with global-owners-override@chromium.org owners
 # by emailing lsc-policy@chromium.org when this list changes.
 
 # per-file rules:
@@ -30,7 +30,6 @@ per-file ..._fuchsia*=file://build/fuchsia/OWNERS
 # For Windows-specific changes:
 per-file ..._win*=file://base/win/OWNERS
 
-per-file callback_list*=pkasting@chromium.org
 per-file feature_list*=asvitkine@chromium.org
 per-file feature_list*=isherman@chromium.org
 
@@ -41,6 +40,8 @@ per-file dcheck*=olivierli@chromium.org
 per-file dcheck*=pbos@chromium.org
 per-file logging*=olivierli@chromium.org
 per-file logging*=pbos@chromium.org
+per-file notimplemented.h=olivierli@chromium.org
+per-file notimplemented.h=pbos@chromium.org
 per-file notreached.h=olivierli@chromium.org
 per-file notreached.h=pbos@chromium.org
 

src/base/PRESUBMIT.py

@@ -8,10 +8,6 @@ See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
 for more details on the presubmit API built into depot_tools.
 """
 
-
-USE_PYTHON3 = True
-
-
 def CheckChangeLintsClean(input_api, output_api):
   """Makes sure that the code is cpplint clean."""
   # lint_filters=[] stops the OFF_BY_DEFAULT_LINT_FILTERS from being disabled,
@@ -40,7 +36,7 @@ def _CheckNoInterfacesInBase(input_api, output_api):
         not "/test/" in f.LocalPath() and
         not f.LocalPath().endswith('.java') and
         not f.LocalPath().endswith('_unittest.mm') and
-        not f.LocalPath().endswith('mac/sdk_forward_declarations.h')):
+        not f.LocalPath().endswith('_spi.h')):
       contents = input_api.ReadFile(f)
       if pattern.search(contents):
         files.append(f)

src/base/SECURITY_OWNERS

@@ -9,5 +9,4 @@
 # yourself, don't hesitate to seek help from another security team member!
 # Nobody knows everything, and the only way to learn is from experience.
 dcheng@chromium.org
-rsesek@chromium.org
 tsepez@chromium.org

src/base/allocator/BUILD.gn

@@ -11,24 +11,18 @@ import("//build/config/dcheck_always_on.gni")
 buildflag_header("buildflags") {
   header = "buildflags.h"
 
-  assert(use_allocator_shim || !use_partition_alloc_as_malloc,
-         "PartitionAlloc-Everywhere requires the allocator shim")
+  use_partition_alloc_as_gwp_asan_store =
+      enable_backup_ref_ptr_support && use_raw_ptr_backup_ref_impl
 
-  flags = [
-    "USE_ALLOCATOR_SHIM=$use_allocator_shim",
-    "USE_PARTITION_ALLOC_AS_MALLOC=$use_partition_alloc_as_malloc",
-
-    "USE_PARTITION_ALLOC_AS_GWP_ASAN_STORE=$enable_backup_ref_ptr_support",
-
-    "FORCE_ENABLE_RAW_PTR_EXCLUSION=$force_enable_raw_ptr_exclusion",
-  ]
+  flags = [ "USE_PARTITION_ALLOC_AS_GWP_ASAN_STORE=$use_partition_alloc_as_gwp_asan_store" ]
 }
 
 if (is_apple) {
-  source_set("early_zone_registration_mac") {
+  source_set("early_zone_registration_apple") {
     sources = [
-      "early_zone_registration_mac.cc",
-      "early_zone_registration_mac.h",
+      "early_zone_registration_apple.cc",
+      "early_zone_registration_apple.h",
+      "partition_allocator/src/partition_alloc/shim/early_zone_registration_constants.h",
     ]
 
     deps = [
@@ -37,43 +31,3 @@ if (is_apple) {
     ]
   }
 }
-
-# Used to shim malloc symbols on Android. see //base/allocator/README.md.
-config("wrap_malloc_symbols") {
-  ldflags = [
-    "-Wl,-wrap,calloc",
-    "-Wl,-wrap,free",
-    "-Wl,-wrap,malloc",
-    "-Wl,-wrap,memalign",
-    "-Wl,-wrap,posix_memalign",
-    "-Wl,-wrap,pvalloc",
-    "-Wl,-wrap,realloc",
-    "-Wl,-wrap,valloc",
-
-    # Not allocating memory, but part of the API
-    "-Wl,-wrap,malloc_usable_size",
-
-    # <stdlib.h> functions
-    "-Wl,-wrap,realpath",
-
-    # <string.h> functions
-    "-Wl,-wrap,strdup",
-    "-Wl,-wrap,strndup",
-
-    # <unistd.h> functions
-    "-Wl,-wrap,getcwd",
-
-    # <stdio.h> functions
-    "-Wl,-wrap,asprintf",
-    "-Wl,-wrap,vasprintf",
-  ]
-}
-
-config("mac_no_default_new_delete_symbols") {
-  if (!is_component_build) {
-    # This is already set when we compile libc++, see
-    # buildtools/third_party/libc++/BUILD.gn. But it needs to be set here as well,
-    # since the shim defines the symbols, to prevent them being exported.
-    cflags = [ "-fvisibility-global-new-delete-hidden" ]
-  }
-}

src/base/allocator/DIR_METADATA

@@ -1,3 +1,6 @@
-monorail {
+monorail: {
   component: "Internals"
 }
+buganizer_public: {
+  component_id: 1456292
+}

src/base/allocator/OWNERS

@@ -1,5 +1,4 @@
 lizeb@chromium.org
-primiano@chromium.org
 wfh@chromium.org
 
 per-file allocator.gni=file://base/allocator/partition_allocator/OWNERS

src/base/allocator/README.md

@@ -35,8 +35,7 @@ indirectly, on `base` within the scope of a linker unit.
 More importantly, **no other place outside of `/base` should depend on the
 specific allocator**.
 If such a functional dependency is required that should be achieved using
-abstractions in `base` (see `/base/allocator/allocator_extension.h` and
-`/base/memory/`)
+abstractions in `base` (see `/base/memory/`)
 
 **Why `base` depends on `allocator`?**
 Because it needs to provide services that depend on the actual allocator
@@ -96,7 +95,7 @@ allocator shim (next point).
 This is taken care of by the headers in `allocator_shim_override_*`.
 
 *On Windows*: Windows' UCRT (Universal C Runtime) exports weak symbols, that we
-can override in `allocator_shim_override_ucr_symbols_win.h`.
+can override in `allocator_shim_override_ucrt_symbols_win.h`.
 
 *On Linux/CrOS*: the allocator symbols are defined as exported global symbols
 in `allocator_shim_override_libc_symbols.h` (for `malloc`, `free` and friends)

src/base/allocator/allocator.gni

@@ -3,44 +3,16 @@
 # found in the LICENSE file.
 
 import("//base/allocator/partition_allocator/partition_alloc.gni")
-import("//build_overrides/partition_alloc.gni")
-
-if (is_ios) {
-  import("//build/config/ios/ios_sdk.gni")
-}
-
-declare_args() {
-  # Causes all the allocations to be routed via allocator_shim.cc.
-  use_allocator_shim = use_allocator_shim_default
-
-  # RAW_PTR_EXCLUSION macro is disabled on official builds because it increased
-  # binary size. This flag can be used to enable it for official builds too.
-  force_enable_raw_ptr_exclusion = false
-}
-
-assert(
-    !use_allocator_shim || is_linux || is_chromeos || is_android || is_win ||
-        is_fuchsia || is_apple,
-    "use_allocator_shim works only on Android, iOS, Linux, macOS, Fuchsia, " +
-        "and Windows.")
-
-if (is_win && use_allocator_shim) {
-  # TODO(crbug.com/1245317): Add a comment indicating why the shim doesn't work.
-  assert(!is_component_build,
-         "The allocator shim doesn't work for the component build on Windows.")
-}
 
 # Chromium-specific asserts. External embedders _may_ elect to use these
 # features even without PA-E.
 if (!use_partition_alloc_as_malloc) {
-  # In theory, BackupRefPtr/MTECheckedPtr will work just fine without
-  # PartitionAlloc-Everywhere, but their scope would be limited to partitions
+  # In theory, BackupRefPtr will work just fine without
+  # PartitionAlloc-Everywhere, but its scope would be limited to partitions
   # that are invoked explicitly (not via malloc). These are only Blink
   # partition, where we currently don't even use raw_ptr<T>.
   assert(!enable_backup_ref_ptr_support,
          "Chromium does not use BRP without PA-E")
-  assert(!enable_mte_checked_ptr_support,
-         "Chromium does not use MTECheckedPtr without PA-E")
 
   # Pointer compression works only if all pointers are guaranteed to be
   # allocated by PA (in one of its core pools, to be precise). In theory,
@@ -50,3 +22,6 @@ if (!use_partition_alloc_as_malloc) {
   assert(!enable_pointer_compression_support,
          "Pointer compressions likely doesn't make sense without PA-E")
 }
+
+assert(use_allocator_shim || !use_partition_alloc_as_malloc,
+       "PartitionAlloc-Everywhere requires the allocator shim")

src/base/allocator/allocator_check.cc

@@ -4,11 +4,11 @@
 
 #include "base/allocator/allocator_check.h"
 
-#include "base/allocator/buildflags.h"
 #include "build/build_config.h"
+#include "partition_alloc/buildflags.h"
 
 #if BUILDFLAG(IS_WIN)
-#include "base/allocator/partition_allocator/shim/winheap_stubs_win.h"
+#include "partition_alloc/shim/winheap_stubs_win.h"
 #endif
 
 #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
@@ -16,18 +16,19 @@
 #endif
 
 #if BUILDFLAG(IS_APPLE)
-#include "base/allocator/partition_allocator/shim/allocator_interception_mac.h"
+#include "partition_alloc/shim/allocator_interception_apple.h"
 #endif
 
 namespace base::allocator {
 
 bool IsAllocatorInitialized() {
-#if BUILDFLAG(IS_WIN) && BUILDFLAG(USE_ALLOCATOR_SHIM)
+#if BUILDFLAG(IS_WIN) && PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
   // Set by allocator_shim_override_ucrt_symbols_win.h when the
   // shimmed _set_new_mode() is called.
   return allocator_shim::g_is_win_shim_layer_initialized;
 #elif BUILDFLAG(IS_APPLE) && !defined(MEMORY_TOOL_REPLACES_ALLOCATOR) && \
-    !BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
+    !PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC) &&                      \
+    PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
   // From allocator_interception_mac.mm.
   return allocator_shim::g_replaced_default_zone;
 #else

src/base/allocator/allocator_extension.cc

@@ -1,15 +0,0 @@
-// Copyright 2012 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/allocator/allocator_extension.h"
-#include "base/allocator/buildflags.h"
-#include "base/check.h"
-
-namespace base {
-namespace allocator {
-
-void ReleaseFreeMemory() {}
-
-}  // namespace allocator
-}  // namespace base

src/base/allocator/allocator_extension.h

@@ -1,23 +0,0 @@
-// Copyright 2012 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_ALLOCATOR_ALLOCATOR_EXTENSION_H_
-#define BASE_ALLOCATOR_ALLOCATOR_EXTENSION_H_
-
-#include <stddef.h>  // for size_t
-
-#include "base/base_export.h"
-#include "build/build_config.h"
-
-namespace base {
-namespace allocator {
-
-// Request that the allocator release any free memory it knows about to the
-// system.
-BASE_EXPORT void ReleaseFreeMemory();
-
-}  // namespace allocator
-}  // namespace base
-
-#endif  // BASE_ALLOCATOR_ALLOCATOR_EXTENSION_H_

src/base/allocator/dispatcher/configuration.h

@@ -21,4 +21,4 @@ constexpr size_t kMaximumNumberOfObservers = 4;
 
 }  // namespace base::allocator::dispatcher::configuration
 
-#endif  // BASE_ALLOCATOR_DISPATCHER_CONFIGURATION_H_
+#endif  // BASE_ALLOCATOR_DISPATCHER_CONFIGURATION_H_

src/base/allocator/dispatcher/dispatcher.cc

@@ -4,263 +4,20 @@
 
 #include "base/allocator/dispatcher/dispatcher.h"
 
-#include "base/allocator/buildflags.h"
 #include "base/allocator/dispatcher/internal/dispatch_data.h"
-#include "base/allocator/dispatcher/reentry_guard.h"
-#include "base/allocator/partition_allocator/partition_alloc.h"
-#include "base/allocator/partition_allocator/partition_alloc_buildflags.h"
-#include "base/allocator/partition_allocator/shim/allocator_shim.h"
 #include "base/check.h"
 #include "base/dcheck_is_on.h"
 #include "base/no_destructor.h"
-#include "base/sampling_heap_profiler/poisson_allocation_sampler.h"
+#include "partition_alloc/buildflags.h"
+#include "partition_alloc/shim/allocator_shim.h"
 
 #if DCHECK_IS_ON()
 #include <atomic>
 #endif
 
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
-namespace base::allocator::dispatcher::allocator_shim_details {
-namespace {
-
-using allocator_shim::AllocatorDispatch;
-
-void* AllocFn(const AllocatorDispatch* self, size_t size, void* context) {
-  ReentryGuard guard;
-  void* address = self->next->alloc_function(self->next, size, context);
-  if (LIKELY(guard)) {
-    PoissonAllocationSampler::RecordAlloc(
-        address, size, PoissonAllocationSampler::kMalloc, nullptr);
-  }
-  return address;
-}
-
-void* AllocUncheckedFn(const AllocatorDispatch* self,
-                       size_t size,
-                       void* context) {
-  ReentryGuard guard;
-  void* address =
-      self->next->alloc_unchecked_function(self->next, size, context);
-  if (LIKELY(guard)) {
-    PoissonAllocationSampler::RecordAlloc(
-        address, size, PoissonAllocationSampler::kMalloc, nullptr);
-  }
-  return address;
-}
-
-void* AllocZeroInitializedFn(const AllocatorDispatch* self,
-                             size_t n,
-                             size_t size,
-                             void* context) {
-  ReentryGuard guard;
-  void* address =
-      self->next->alloc_zero_initialized_function(self->next, n, size, context);
-  if (LIKELY(guard)) {
-    PoissonAllocationSampler::RecordAlloc(
-        address, n * size, PoissonAllocationSampler::kMalloc, nullptr);
-  }
-  return address;
-}
-
-void* AllocAlignedFn(const AllocatorDispatch* self,
-                     size_t alignment,
-                     size_t size,
-                     void* context) {
-  ReentryGuard guard;
-  void* address =
-      self->next->alloc_aligned_function(self->next, alignment, size, context);
-  if (LIKELY(guard)) {
-    PoissonAllocationSampler::RecordAlloc(
-        address, size, PoissonAllocationSampler::kMalloc, nullptr);
-  }
-  return address;
-}
-
-void* ReallocFn(const AllocatorDispatch* self,
-                void* address,
-                size_t size,
-                void* context) {
-  ReentryGuard guard;
-  // Note: size == 0 actually performs free.
-  PoissonAllocationSampler::RecordFree(address);
-  address = self->next->realloc_function(self->next, address, size, context);
-  if (LIKELY(guard)) {
-    PoissonAllocationSampler::RecordAlloc(
-        address, size, PoissonAllocationSampler::kMalloc, nullptr);
-  }
-  return address;
-}
-
-void FreeFn(const AllocatorDispatch* self, void* address, void* context) {
-  // Note: The RecordFree should be called before free_function
-  // (here and in other places).
-  // That is because we need to remove the recorded allocation sample before
-  // free_function, as once the latter is executed the address becomes available
-  // and can be allocated by another thread. That would be racy otherwise.
-  PoissonAllocationSampler::RecordFree(address);
-  self->next->free_function(self->next, address, context);
-}
-
-size_t GetSizeEstimateFn(const AllocatorDispatch* self,
-                         void* address,
-                         void* context) {
-  return self->next->get_size_estimate_function(self->next, address, context);
-}
-
-bool ClaimedAddressFn(const AllocatorDispatch* self,
-                      void* address,
-                      void* context) {
-  return self->next->claimed_address_function(self->next, address, context);
-}
-
-unsigned BatchMallocFn(const AllocatorDispatch* self,
-                       size_t size,
-                       void** results,
-                       unsigned num_requested,
-                       void* context) {
-  ReentryGuard guard;
-  unsigned num_allocated = self->next->batch_malloc_function(
-      self->next, size, results, num_requested, context);
-  if (LIKELY(guard)) {
-    for (unsigned i = 0; i < num_allocated; ++i) {
-      PoissonAllocationSampler::RecordAlloc(
-          results[i], size, PoissonAllocationSampler::kMalloc, nullptr);
-    }
-  }
-  return num_allocated;
-}
-
-void BatchFreeFn(const AllocatorDispatch* self,
-                 void** to_be_freed,
-                 unsigned num_to_be_freed,
-                 void* context) {
-  for (unsigned i = 0; i < num_to_be_freed; ++i)
-    PoissonAllocationSampler::RecordFree(to_be_freed[i]);
-  self->next->batch_free_function(self->next, to_be_freed, num_to_be_freed,
-                                  context);
-}
-
-void FreeDefiniteSizeFn(const AllocatorDispatch* self,
-                        void* address,
-                        size_t size,
-                        void* context) {
-  PoissonAllocationSampler::RecordFree(address);
-  self->next->free_definite_size_function(self->next, address, size, context);
-}
-
-void TryFreeDefaultFn(const AllocatorDispatch* self,
-                      void* address,
-                      void* context) {
-  PoissonAllocationSampler::RecordFree(address);
-  self->next->try_free_default_function(self->next, address, context);
-}
-
-static void* AlignedMallocFn(const AllocatorDispatch* self,
-                             size_t size,
-                             size_t alignment,
-                             void* context) {
-  ReentryGuard guard;
-  void* address =
-      self->next->aligned_malloc_function(self->next, size, alignment, context);
-  if (LIKELY(guard)) {
-    PoissonAllocationSampler::RecordAlloc(
-        address, size, PoissonAllocationSampler::kMalloc, nullptr);
-  }
-  return address;
-}
-
-static void* AlignedReallocFn(const AllocatorDispatch* self,
-                              void* address,
-                              size_t size,
-                              size_t alignment,
-                              void* context) {
-  ReentryGuard guard;
-  // Note: size == 0 actually performs free.
-  PoissonAllocationSampler::RecordFree(address);
-  address = self->next->aligned_realloc_function(self->next, address, size,
-                                                 alignment, context);
-  if (LIKELY(guard)) {
-    PoissonAllocationSampler::RecordAlloc(
-        address, size, PoissonAllocationSampler::kMalloc, nullptr);
-  }
-  return address;
-}
-
-static void AlignedFreeFn(const AllocatorDispatch* self,
-                          void* address,
-                          void* context) {
-  PoissonAllocationSampler::RecordFree(address);
-  self->next->aligned_free_function(self->next, address, context);
-}
-
-AllocatorDispatch g_allocator_dispatch = {&AllocFn,
-                                          &AllocUncheckedFn,
-                                          &AllocZeroInitializedFn,
-                                          &AllocAlignedFn,
-                                          &ReallocFn,
-                                          &FreeFn,
-                                          &GetSizeEstimateFn,
-                                          &ClaimedAddressFn,
-                                          &BatchMallocFn,
-                                          &BatchFreeFn,
-                                          &FreeDefiniteSizeFn,
-                                          &TryFreeDefaultFn,
-                                          &AlignedMallocFn,
-                                          &AlignedReallocFn,
-                                          &AlignedFreeFn,
-                                          nullptr};
-
-}  // namespace
-}  // namespace base::allocator::dispatcher::allocator_shim_details
-#endif  // BUILDFLAG(USE_ALLOCATOR_SHIM)
-
-#if BUILDFLAG(USE_PARTITION_ALLOC) && !BUILDFLAG(IS_NACL)
-namespace base::allocator::dispatcher::partition_allocator_details {
-namespace {
-
-void PartitionAllocHook(void* address, size_t size, const char* type) {
-  PoissonAllocationSampler::RecordAlloc(
-      address, size, PoissonAllocationSampler::kPartitionAlloc, type);
-}
-
-void PartitionFreeHook(void* address) {
-  PoissonAllocationSampler::RecordFree(address);
-}
-
-}  // namespace
-}  // namespace base::allocator::dispatcher::partition_allocator_details
-#endif  // BUILDFLAG(USE_PARTITION_ALLOC) && !BUILDFLAG(IS_NACL)
-
-namespace base::allocator::dispatcher {
-
-void InstallStandardAllocatorHooks() {
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
-  allocator_shim::InsertAllocatorDispatch(
-      &allocator_shim_details::g_allocator_dispatch);
-#else
-  // If the allocator shim isn't available, then we don't install any hooks.
-  // There's no point in printing an error message, since this can regularly
-  // happen for tests.
-#endif  // BUILDFLAG(USE_ALLOCATOR_SHIM)
-
-#if BUILDFLAG(USE_PARTITION_ALLOC) && !BUILDFLAG(IS_NACL)
-  partition_alloc::PartitionAllocHooks::SetObserverHooks(
-      &partition_allocator_details::PartitionAllocHook,
-      &partition_allocator_details::PartitionFreeHook);
-#endif  // BUILDFLAG(USE_PARTITION_ALLOC) && !BUILDFLAG(IS_NACL)
-}
-
-void RemoveStandardAllocatorHooksForTesting() {
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
-  allocator_shim::RemoveAllocatorDispatchForTesting(
-      &allocator_shim_details::g_allocator_dispatch);  // IN-TEST
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC)
+#include "partition_alloc/partition_alloc_hooks.h"  // nogncheck
 #endif
-#if BUILDFLAG(USE_PARTITION_ALLOC) && !BUILDFLAG(IS_NACL)
-  partition_alloc::PartitionAllocHooks::SetObserverHooks(nullptr, nullptr);
-#endif
-}
-
-}  // namespace base::allocator::dispatcher
 
 namespace base::allocator::dispatcher {
 
@@ -277,7 +34,7 @@ struct Dispatcher::Impl {
 
   void Reset() {
 #if DCHECK_IS_ON()
-    DCHECK([&]() {
+    DCHECK([&] {
       auto const was_set = is_initialized_check_flag_.test_and_set();
       is_initialized_check_flag_.clear();
       return was_set;
@@ -294,13 +51,13 @@ struct Dispatcher::Impl {
   // connected. This way we prevent notifications although no observers are
   // present.
   static void ConnectToEmitters(const internal::DispatchData& dispatch_data) {
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
+#if PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
     if (auto* const allocator_dispatch = dispatch_data.GetAllocatorDispatch()) {
       allocator_shim::InsertAllocatorDispatch(allocator_dispatch);
     }
 #endif
 
-#if BUILDFLAG(USE_PARTITION_ALLOC)
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC)
     {
       auto* const allocation_hook = dispatch_data.GetAllocationObserverHook();
       auto* const free_hook = dispatch_data.GetFreeObserverHook();
@@ -313,14 +70,14 @@ struct Dispatcher::Impl {
   }
 
   static void DisconnectFromEmitters(internal::DispatchData& dispatch_data) {
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
+#if PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
     if (auto* const allocator_dispatch = dispatch_data.GetAllocatorDispatch()) {
       allocator_shim::RemoveAllocatorDispatchForTesting(
           allocator_dispatch);  // IN-TEST
     }
 #endif
 
-#if BUILDFLAG(USE_PARTITION_ALLOC)
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC)
     partition_alloc::PartitionAllocHooks::SetObserverHooks(nullptr, nullptr);
 #endif
   }

src/base/allocator/dispatcher/dispatcher.h

@@ -5,16 +5,13 @@
 #ifndef BASE_ALLOCATOR_DISPATCHER_DISPATCHER_H_
 #define BASE_ALLOCATOR_DISPATCHER_DISPATCHER_H_
 
+#include <memory>
+
 #include "base/allocator/dispatcher/internal/dispatcher_internal.h"
 #include "base/base_export.h"
 
-#include <memory>
-
 namespace base::allocator::dispatcher {
 
-void BASE_EXPORT InstallStandardAllocatorHooks();
-void BASE_EXPORT RemoveStandardAllocatorHooksForTesting();
-
 namespace internal {
 struct DispatchData;
 }
@@ -75,4 +72,4 @@ class BASE_EXPORT Dispatcher {
 };
 }  // namespace base::allocator::dispatcher
 
-#endif  // BASE_ALLOCATOR_DISPATCHER_DISPATCHER_H_
+#endif  // BASE_ALLOCATOR_DISPATCHER_DISPATCHER_H_

src/base/allocator/dispatcher/initializer.h

@@ -5,13 +5,13 @@
 #ifndef BASE_ALLOCATOR_DISPATCHER_INITIALIZER_H_
 #define BASE_ALLOCATOR_DISPATCHER_INITIALIZER_H_
 
+#include <tuple>
+#include <utility>
+
 #include "base/allocator/dispatcher/configuration.h"
 #include "base/allocator/dispatcher/dispatcher.h"
 #include "base/allocator/dispatcher/internal/tools.h"
 
-#include <tuple>
-#include <utility>
-
 namespace base::allocator::dispatcher {
 namespace internal {
 
@@ -28,7 +28,7 @@ inline void DoInitialize(DispatcherType& dispatcher,
                          const VerifiedObservers& verified_observers,
                          const UnverifiedObservers& unverified_observers,
                          std::index_sequence<IndicesToSelect...> indices) {
-  if constexpr (CurrentIndex < std::tuple_size<UnverifiedObservers>::value) {
+  if constexpr (CurrentIndex < std::tuple_size_v<UnverifiedObservers>) {
     // We still have some items left to handle.
     if (check_observer(std::get<CurrentIndex>(unverified_observers))) {
       // The current observer is valid. Hence, append the index of the current
@@ -43,8 +43,7 @@ inline void DoInitialize(DispatcherType& dispatcher,
                                      verified_observers, unverified_observers,
                                      indices);
     }
-  } else if constexpr (CurrentIndex ==
-                       std::tuple_size<UnverifiedObservers>::value) {
+  } else if constexpr (CurrentIndex == std::tuple_size_v<UnverifiedObservers>) {
     // So we have met the end of the tuple of observers to verify.
     // Hence, we extract the additional valid observers, append to the tuple of
     // already verified observers and hand over to the dispatcher.
@@ -54,7 +53,7 @@ inline void DoInitialize(DispatcherType& dispatcher,
 
     // Do a final check that neither the maximum total number of observers nor
     // the maximum number of optional observers is exceeded.
-    static_assert(std::tuple_size<decltype(observers)>::value <=
+    static_assert(std::tuple_size_v<decltype(observers)> <=
                   configuration::kMaximumNumberOfObservers);
     static_assert(sizeof...(IndicesToSelect) <=
                   configuration::kMaximumNumberOfOptionalObservers);
@@ -102,7 +101,7 @@ struct BASE_EXPORT Initializer {
   template <typename... NewMandatoryObservers,
             std::enable_if_t<
                 internal::LessEqual((sizeof...(NewMandatoryObservers) +
-                                     std::tuple_size<OptionalObservers>::value),
+                                     std::tuple_size_v<OptionalObservers>),
                                     configuration::kMaximumNumberOfObservers),
                 bool> = true>
   Initializer<std::tuple<NewMandatoryObservers*...>, OptionalObservers>
@@ -115,9 +114,9 @@ struct BASE_EXPORT Initializer {
   // configuration::maximum_number_of_observers.
   template <typename... AdditionalMandatoryObservers,
             std::enable_if_t<internal::LessEqual(
-                                 std::tuple_size<MandatoryObservers>::value +
+                                 std::tuple_size_v<MandatoryObservers> +
                                      sizeof...(AdditionalMandatoryObservers) +
-                                     std::tuple_size<OptionalObservers>::value,
+                                     std::tuple_size_v<OptionalObservers>,
                                  configuration::kMaximumNumberOfObservers),
                              bool> = true>
   Initializer<TupleCat<MandatoryObservers,
@@ -140,7 +139,7 @@ struct BASE_EXPORT Initializer {
               sizeof...(NewOptionalObservers),
               configuration::kMaximumNumberOfOptionalObservers) &&
               internal::LessEqual((sizeof...(NewOptionalObservers) +
-                                   std::tuple_size<MandatoryObservers>::value),
+                                   std::tuple_size_v<MandatoryObservers>),
                                   configuration::kMaximumNumberOfObservers),
           bool> = true>
   Initializer<MandatoryObservers, std::tuple<NewOptionalObservers*...>>
@@ -156,12 +155,12 @@ struct BASE_EXPORT Initializer {
       typename... AdditionalOptionalObservers,
       std::enable_if_t<
           internal::LessEqual(
-              std::tuple_size<OptionalObservers>::value +
+              std::tuple_size_v<OptionalObservers> +
                   sizeof...(AdditionalOptionalObservers),
               configuration::kMaximumNumberOfOptionalObservers) &&
-              internal::LessEqual((std::tuple_size<OptionalObservers>::value +
+              internal::LessEqual((std::tuple_size_v<OptionalObservers> +
                                    sizeof...(AdditionalOptionalObservers) +
-                                   std::tuple_size<MandatoryObservers>::value),
+                                   std::tuple_size_v<MandatoryObservers>),
                                   configuration::kMaximumNumberOfObservers),
           bool> = true>
   Initializer<
@@ -203,4 +202,4 @@ inline Initializer<> CreateInitializer() {
 
 }  // namespace base::allocator::dispatcher
 
-#endif  // BASE_ALLOCATOR_DISPATCHER_INITIALIZER_H_
+#endif  // BASE_ALLOCATOR_DISPATCHER_INITIALIZER_H_

src/base/allocator/dispatcher/internal/dispatch_data.cc

@@ -3,11 +3,12 @@
 // found in the LICENSE file.
 
 #include "base/allocator/dispatcher/internal/dispatch_data.h"
-#include "base/allocator/partition_allocator/partition_alloc_buildflags.h"
+
+#include "partition_alloc/buildflags.h"
 
 namespace base::allocator::dispatcher::internal {
 
-#if BUILDFLAG(USE_PARTITION_ALLOC)
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC)
 
 DispatchData& DispatchData::SetAllocationObserverHooks(
     AllocationObserverHook* allocation_observer_hook,
@@ -28,7 +29,7 @@ DispatchData::FreeObserverHook* DispatchData::GetFreeObserverHook() const {
 }
 #endif
 
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
+#if PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
 DispatchData& DispatchData::SetAllocatorDispatch(
     AllocatorDispatch* allocator_dispatch) {
   allocator_dispatch_ = allocator_dispatch;

src/base/allocator/dispatcher/internal/dispatch_data.h

@@ -5,29 +5,28 @@
 #ifndef BASE_ALLOCATOR_DISPATCHER_INTERNAL_DISPATCH_DATA_H_
 #define BASE_ALLOCATOR_DISPATCHER_INTERNAL_DISPATCH_DATA_H_
 
-#include "base/allocator/buildflags.h"
-#include "base/allocator/partition_allocator/partition_alloc_buildflags.h"
 #include "base/base_export.h"
 #include "build/build_config.h"
+#include "partition_alloc/buildflags.h"
 
-#if BUILDFLAG(USE_PARTITION_ALLOC)
-#include "base/allocator/partition_allocator/partition_alloc.h"
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC)
+#include "partition_alloc/partition_alloc_hooks.h"  // nogncheck
 #endif
 
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
-#include "base/allocator/partition_allocator/shim/allocator_shim.h"
+#if PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
+#include "partition_alloc/shim/allocator_shim.h"  // nogncheck
 #endif
 
 namespace base::allocator::dispatcher::internal {
 
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
+#if PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
 using allocator_shim::AllocatorDispatch;
 #endif
 
 // A simple utility class to pass all the information required to properly hook
 // into the memory allocation subsystems from DispatcherImpl to the Dispatcher.
 struct BASE_EXPORT DispatchData {
-#if BUILDFLAG(USE_PARTITION_ALLOC)
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC)
   using AllocationObserverHook =
       partition_alloc::PartitionAllocHooks::AllocationObserverHook;
   using FreeObserverHook =
@@ -45,7 +44,7 @@ struct BASE_EXPORT DispatchData {
  public:
 #endif
 
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
+#if PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
   DispatchData& SetAllocatorDispatch(AllocatorDispatch* allocator_dispatch);
   AllocatorDispatch* GetAllocatorDispatch() const;
 
@@ -56,4 +55,4 @@ struct BASE_EXPORT DispatchData {
 
 }  // namespace base::allocator::dispatcher::internal
 
-#endif
+#endif  // BASE_ALLOCATOR_DISPATCHER_INTERNAL_DISPATCH_DATA_H_

src/base/allocator/dispatcher/internal/dispatcher_internal.h

@@ -5,29 +5,29 @@
 #ifndef BASE_ALLOCATOR_DISPATCHER_INTERNAL_DISPATCHER_INTERNAL_H_
 #define BASE_ALLOCATOR_DISPATCHER_INTERNAL_DISPATCHER_INTERNAL_H_
 
-#include "base/allocator/buildflags.h"
 #include "base/allocator/dispatcher/configuration.h"
 #include "base/allocator/dispatcher/internal/dispatch_data.h"
 #include "base/allocator/dispatcher/internal/tools.h"
-#include "base/allocator/dispatcher/reentry_guard.h"
+#include "base/allocator/dispatcher/memory_tagging.h"
+#include "base/allocator/dispatcher/notification_data.h"
 #include "base/allocator/dispatcher/subsystem.h"
-#include "base/allocator/partition_allocator/partition_alloc_buildflags.h"
+#include "base/check.h"
 #include "base/compiler_specific.h"
-#include "build/build_config.h"
+#include "partition_alloc/buildflags.h"
 
-#if BUILDFLAG(USE_PARTITION_ALLOC)
-#include "base/allocator/partition_allocator/partition_alloc.h"
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC)
+#include "partition_alloc/partition_alloc_allocation_data.h"  // nogncheck
 #endif
 
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
-#include "base/allocator/partition_allocator/shim/allocator_shim.h"
+#if PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
+#include "partition_alloc/shim/allocator_shim.h"
 #endif
 
 #include <tuple>
 
 namespace base::allocator::dispatcher::internal {
 
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
+#if PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
 using allocator_shim::AllocatorDispatch;
 #endif
 
@@ -45,21 +45,16 @@ template <typename... ObserverTypes, size_t... Indices>
 ALWAYS_INLINE void PerformAllocationNotification(
     const std::tuple<ObserverTypes...>& observers,
     std::index_sequence<Indices...>,
-    void* address,
-    size_t size,
-    AllocationSubsystem subSystem,
-    const char* type_name) {
-  ((std::get<Indices>(observers)->OnAllocation(address, size, subSystem,
-                                               type_name)),
-   ...);
+    const AllocationNotificationData& notification_data) {
+  ((std::get<Indices>(observers)->OnAllocation(notification_data)), ...);
 }
 
 template <typename... ObserverTypes, size_t... Indices>
 ALWAYS_INLINE void PerformFreeNotification(
     const std::tuple<ObserverTypes...>& observers,
     std::index_sequence<Indices...>,
-    void* address) {
-  ((std::get<Indices>(observers)->OnFree(address)), ...);
+    const FreeNotificationData& notification_data) {
+  ((std::get<Indices>(observers)->OnFree(notification_data)), ...);
 }
 
 // DispatcherImpl provides hooks into the various memory subsystems. These hooks
@@ -88,230 +83,236 @@ struct DispatcherImpl {
  private:
   static DispatchData CreateDispatchData() {
     return DispatchData()
-#if BUILDFLAG(USE_PARTITION_ALLOC)
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC)
         .SetAllocationObserverHooks(&PartitionAllocatorAllocationHook,
                                     &PartitionAllocatorFreeHook)
 #endif
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
+#if PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
         .SetAllocatorDispatch(&allocator_dispatch_)
 #endif
         ;
   }
 
-#if BUILDFLAG(USE_PARTITION_ALLOC)
-  static void PartitionAllocatorAllocationHook(void* address,
-                                               size_t size,
-                                               const char* type_name) {
-    DoNotifyAllocation(address, size, AllocationSubsystem::kPartitionAllocator,
-                       type_name);
-  }
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC)
+  static void PartitionAllocatorAllocationHook(
+      const partition_alloc::AllocationNotificationData& pa_notification_data) {
+    AllocationNotificationData dispatcher_notification_data(
+        pa_notification_data.address(), pa_notification_data.size(),
+        pa_notification_data.type_name(),
+        AllocationSubsystem::kPartitionAllocator);
 
-  static void PartitionAllocatorFreeHook(void* address) {
-    DoNotifyFree(address);
-  }
+#if PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+    dispatcher_notification_data.SetMteReportingMode(
+        ConvertToMTEMode(pa_notification_data.mte_reporting_mode()));
 #endif
 
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
-  static void* AllocFn(const AllocatorDispatch* self,
-                       size_t size,
-                       void* context) {
-    ReentryGuard guard;
-    void* const address = self->next->alloc_function(self->next, size, context);
-    if (LIKELY(guard)) {
-      DoNotifyAllocation(address, size, AllocationSubsystem::kAllocatorShim);
-    }
-    return address;
+    DoNotifyAllocation(dispatcher_notification_data);
   }
 
-  static void* AllocUncheckedFn(const AllocatorDispatch* self,
-                                size_t size,
-                                void* context) {
-    ReentryGuard guard;
+  static void PartitionAllocatorFreeHook(
+      const partition_alloc::FreeNotificationData& pa_notification_data) {
+    FreeNotificationData dispatcher_notification_data(
+        pa_notification_data.address(),
+        AllocationSubsystem::kPartitionAllocator);
+
+#if PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+    dispatcher_notification_data.SetMteReportingMode(
+        ConvertToMTEMode(pa_notification_data.mte_reporting_mode()));
+#endif
+
+    DoNotifyFree(dispatcher_notification_data);
+  }
+#endif  // PA_BUILDFLAG(USE_PARTITION_ALLOC)
+
+#if PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
+  static void* AllocFn(size_t size, void* context) {
     void* const address =
-        self->next->alloc_unchecked_function(self->next, size, context);
-    if (LIKELY(guard)) {
-      DoNotifyAllocation(address, size, AllocationSubsystem::kAllocatorShim);
-    }
+        allocator_dispatch_.next->alloc_function(size, context);
+
+    DoNotifyAllocationForShim(address, size);
+
     return address;
   }
 
-  static void* AllocZeroInitializedFn(const AllocatorDispatch* self,
-                                      size_t n,
-                                      size_t size,
-                                      void* context) {
-    ReentryGuard guard;
-    void* const address = self->next->alloc_zero_initialized_function(
-        self->next, n, size, context);
-    if (LIKELY(guard)) {
-      DoNotifyAllocation(address, n * size,
-                         AllocationSubsystem::kAllocatorShim);
-    }
+  static void* AllocUncheckedFn(size_t size, void* context) {
+    void* const address =
+        allocator_dispatch_.next->alloc_unchecked_function(size, context);
+
+    DoNotifyAllocationForShim(address, size);
+
     return address;
   }
 
-  static void* AllocAlignedFn(const AllocatorDispatch* self,
-                              size_t alignment,
-                              size_t size,
-                              void* context) {
-    ReentryGuard guard;
-    void* const address = self->next->alloc_aligned_function(
-        self->next, alignment, size, context);
-    if (LIKELY(guard)) {
-      DoNotifyAllocation(address, size, AllocationSubsystem::kAllocatorShim);
-    }
+  static void* AllocZeroInitializedFn(size_t n, size_t size, void* context) {
+    void* const address =
+        allocator_dispatch_.next->alloc_zero_initialized_function(n, size,
+                                                                  context);
+
+    DoNotifyAllocationForShim(address, n * size);
+
     return address;
   }
 
-  static void* ReallocFn(const AllocatorDispatch* self,
-                         void* address,
-                         size_t size,
-                         void* context) {
-    ReentryGuard guard;
+  static void* AllocAlignedFn(size_t alignment, size_t size, void* context) {
+    void* const address = allocator_dispatch_.next->alloc_aligned_function(
+        alignment, size, context);
+
+    DoNotifyAllocationForShim(address, size);
+
+    return address;
+  }
+
+  static void* ReallocFn(void* address, size_t size, void* context) {
     // Note: size == 0 actually performs free.
-    // Note: ReentryGuard prevents from recursions introduced by malloc and
-    // initialization of thread local storage which happen in the allocation
-    // path only (please see docs of ReentryGuard for full details). Therefore,
-    // the DoNotifyFree doesn't need to be guarded. Instead, making it unguarded
-    // also ensures proper notification.
-    DoNotifyFree(address);
+    DoNotifyFreeForShim(address);
     void* const reallocated_address =
-        self->next->realloc_function(self->next, address, size, context);
-    if (LIKELY(guard)) {
-      DoNotifyAllocation(reallocated_address, size,
-                         AllocationSubsystem::kAllocatorShim);
-    }
+        allocator_dispatch_.next->realloc_function(address, size, context);
+
+    DoNotifyAllocationForShim(reallocated_address, size);
+
     return reallocated_address;
   }
 
-  static void FreeFn(const AllocatorDispatch* self,
-                     void* address,
-                     void* context) {
-    // Note: The RecordFree should be called before free_function (here and in
+  static void* ReallocUncheckedFn(void* address, size_t size, void* context) {
+    // Note: size == 0 actually performs free.
+    DoNotifyFreeForShim(address);
+    void* const reallocated_address =
+        allocator_dispatch_.next->realloc_unchecked_function(address, size,
+                                                             context);
+
+    DoNotifyAllocationForShim(reallocated_address, size);
+
+    return reallocated_address;
+  }
+
+  static void FreeFn(void* address, void* context) {
+    // Note: DoNotifyFree should be called before free_function (here and in
     // other places). That is because observers need to handle the allocation
     // being freed before calling free_function, as once the latter is executed
     // the address becomes available and can be allocated by another thread.
     // That would be racy otherwise.
-    // Note: The code doesn't need to protect from recursions using
-    // ReentryGuard, see ReallocFn for details.
-    DoNotifyFree(address);
-    self->next->free_function(self->next, address, context);
+    DoNotifyFreeForShim(address);
+    MUSTTAIL return allocator_dispatch_.next->free_function(address, context);
   }
 
-  static size_t GetSizeEstimateFn(const AllocatorDispatch* self,
-                                  void* address,
-                                  void* context) {
-    return self->next->get_size_estimate_function(self->next, address, context);
-  }
-
-  static bool ClaimedAddressFn(const AllocatorDispatch* self,
-                               void* address,
-                               void* context) {
-    return self->next->claimed_address_function(self->next, address, context);
-  }
-
-  static unsigned BatchMallocFn(const AllocatorDispatch* self,
-                                size_t size,
+  static unsigned BatchMallocFn(size_t size,
                                 void** results,
                                 unsigned num_requested,
                                 void* context) {
-    ReentryGuard guard;
-    unsigned const num_allocated = self->next->batch_malloc_function(
-        self->next, size, results, num_requested, context);
-    if (LIKELY(guard)) {
-      for (unsigned i = 0; i < num_allocated; ++i) {
-        DoNotifyAllocation(results[i], size,
-                           AllocationSubsystem::kAllocatorShim);
-      }
+    unsigned const num_allocated =
+        allocator_dispatch_.next->batch_malloc_function(size, results,
+                                                        num_requested, context);
+    for (unsigned i = 0; i < num_allocated; ++i) {
+      DoNotifyAllocationForShim(results[i], size);
     }
     return num_allocated;
   }
 
-  static void BatchFreeFn(const AllocatorDispatch* self,
-                          void** to_be_freed,
+  static void BatchFreeFn(void** to_be_freed,
                           unsigned num_to_be_freed,
                           void* context) {
-    // Note: The code doesn't need to protect from recursions using
-    // ReentryGuard, see ReallocFn for details.
     for (unsigned i = 0; i < num_to_be_freed; ++i) {
-      DoNotifyFree(to_be_freed[i]);
+      DoNotifyFreeForShim(to_be_freed[i]);
     }
-    self->next->batch_free_function(self->next, to_be_freed, num_to_be_freed,
-                                    context);
+
+    MUSTTAIL return allocator_dispatch_.next->batch_free_function(
+        to_be_freed, num_to_be_freed, context);
   }
 
-  static void FreeDefiniteSizeFn(const AllocatorDispatch* self,
-                                 void* address,
-                                 size_t size,
-                                 void* context) {
-    // Note: The code doesn't need to protect from recursions using
-    // ReentryGuard, see ReallocFn for details.
-    DoNotifyFree(address);
-    self->next->free_definite_size_function(self->next, address, size, context);
+  static void FreeDefiniteSizeFn(void* address, size_t size, void* context) {
+    DoNotifyFreeForShim(address);
+    MUSTTAIL return allocator_dispatch_.next->free_definite_size_function(
+        address, size, context);
   }
 
-  static void TryFreeDefaultFn(const AllocatorDispatch* self,
-                               void* address,
-                               void* context) {
-    DoNotifyFree(address);
-    self->next->try_free_default_function(self->next, address, context);
+  static void TryFreeDefaultFn(void* address, void* context) {
+    DoNotifyFreeForShim(address);
+    MUSTTAIL return allocator_dispatch_.next->try_free_default_function(
+        address, context);
   }
 
-  static void* AlignedMallocFn(const AllocatorDispatch* self,
-                               size_t size,
-                               size_t alignment,
-                               void* context) {
-    ReentryGuard guard;
-    void* const address = self->next->aligned_malloc_function(
-        self->next, size, alignment, context);
-    if (LIKELY(guard)) {
-      DoNotifyAllocation(address, size, AllocationSubsystem::kAllocatorShim);
-    }
+  static void* AlignedMallocFn(size_t size, size_t alignment, void* context) {
+    void* const address = allocator_dispatch_.next->aligned_malloc_function(
+        size, alignment, context);
+
+    DoNotifyAllocationForShim(address, size);
+
     return address;
   }
 
-  static void* AlignedReallocFn(const AllocatorDispatch* self,
-                                void* address,
+  static void* AlignedMallocUncheckedFn(size_t size,
+                                        size_t alignment,
+                                        void* context) {
+    void* const address =
+        allocator_dispatch_.next->aligned_malloc_unchecked_function(
+            size, alignment, context);
+
+    DoNotifyAllocationForShim(address, size);
+
+    return address;
+  }
+
+  static void* AlignedReallocFn(void* address,
                                 size_t size,
                                 size_t alignment,
                                 void* context) {
-    ReentryGuard guard;
     // Note: size == 0 actually performs free.
-    // Note: DoNotifyFree doesn't need to protect from recursions using
-    // ReentryGuard, see ReallocFn for details.
-    // Instead, making it unguarded also ensures proper notification of the free
-    // portion.
-    DoNotifyFree(address);
-    address = self->next->aligned_realloc_function(self->next, address, size,
-                                                   alignment, context);
-    if (LIKELY(guard)) {
-      DoNotifyAllocation(address, size, AllocationSubsystem::kAllocatorShim);
-    }
+    DoNotifyFreeForShim(address);
+    address = allocator_dispatch_.next->aligned_realloc_function(
+        address, size, alignment, context);
+
+    DoNotifyAllocationForShim(address, size);
+
     return address;
   }
 
-  static void AlignedFreeFn(const AllocatorDispatch* self,
-                            void* address,
-                            void* context) {
-    // Note: The code doesn't need to protect from recursions using
-    // ReentryGuard, see ReallocFn for details.
-    DoNotifyFree(address);
-    self->next->aligned_free_function(self->next, address, context);
+  static void* AlignedReallocUncheckedFn(void* address,
+                                         size_t size,
+                                         size_t alignment,
+                                         void* context) {
+    // Note: size == 0 actually performs free.
+    DoNotifyFreeForShim(address);
+    address = allocator_dispatch_.next->aligned_realloc_unchecked_function(
+        address, size, alignment, context);
+
+    DoNotifyAllocationForShim(address, size);
+
+    return address;
+  }
+
+  static void AlignedFreeFn(void* address, void* context) {
+    DoNotifyFreeForShim(address);
+    MUSTTAIL return allocator_dispatch_.next->aligned_free_function(address,
+                                                                    context);
+  }
+
+  ALWAYS_INLINE static void DoNotifyAllocationForShim(void* address,
+                                                      size_t size) {
+    AllocationNotificationData notification_data(
+        address, size, nullptr, AllocationSubsystem::kAllocatorShim);
+
+    DoNotifyAllocation(notification_data);
+  }
+
+  ALWAYS_INLINE static void DoNotifyFreeForShim(void* address) {
+    FreeNotificationData notification_data(address,
+                                           AllocationSubsystem::kAllocatorShim);
+
+    DoNotifyFree(notification_data);
   }
 
   static AllocatorDispatch allocator_dispatch_;
-#endif
+#endif  // PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
 
-  static ALWAYS_INLINE void DoNotifyAllocation(
-      void* address,
-      size_t size,
-      AllocationSubsystem subSystem,
-      const char* type_name = nullptr) {
-    PerformAllocationNotification(s_observers, AllObservers{}, address, size,
-                                  subSystem, type_name);
+  ALWAYS_INLINE static void DoNotifyAllocation(
+      const AllocationNotificationData& notification_data) {
+    PerformAllocationNotification(s_observers, AllObservers{},
+                                  notification_data);
   }
 
-  static ALWAYS_INLINE void DoNotifyFree(void* address) {
-    PerformFreeNotification(s_observers, AllObservers{}, address);
+  ALWAYS_INLINE static void DoNotifyFree(
+      const FreeNotificationData& notification_data) {
+    PerformFreeNotification(s_observers, AllObservers{}, notification_data);
   }
 
   static std::tuple<ObserverTypes*...> s_observers;
@@ -320,26 +321,31 @@ struct DispatcherImpl {
 template <typename... ObserverTypes>
 std::tuple<ObserverTypes*...> DispatcherImpl<ObserverTypes...>::s_observers;
 
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
+#if PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
 template <typename... ObserverTypes>
 AllocatorDispatch DispatcherImpl<ObserverTypes...>::allocator_dispatch_ = {
-    &AllocFn,
-    &AllocUncheckedFn,
-    &AllocZeroInitializedFn,
-    &AllocAlignedFn,
-    &ReallocFn,
-    &FreeFn,
-    &GetSizeEstimateFn,
-    &ClaimedAddressFn,
-    &BatchMallocFn,
-    &BatchFreeFn,
-    &FreeDefiniteSizeFn,
-    &TryFreeDefaultFn,
-    &AlignedMallocFn,
-    &AlignedReallocFn,
-    &AlignedFreeFn,
-    nullptr};
-#endif
+    AllocFn,                    // alloc_function
+    AllocUncheckedFn,           // alloc_unchecked_function
+    AllocZeroInitializedFn,     // alloc_zero_initialized_function
+    AllocAlignedFn,             // alloc_aligned_function
+    ReallocFn,                  // realloc_function
+    ReallocUncheckedFn,         // realloc_unchecked_function
+    FreeFn,                     // free_function
+    nullptr,                    // get_size_estimate_function
+    nullptr,                    // good_size_function
+    nullptr,                    // claimed_address_function
+    BatchMallocFn,              // batch_malloc_function
+    BatchFreeFn,                // batch_free_function
+    FreeDefiniteSizeFn,         // free_definite_size_function
+    TryFreeDefaultFn,           // try_free_default_function
+    AlignedMallocFn,            // aligned_malloc_function
+    AlignedMallocUncheckedFn,   // aligned_malloc_unchecked_function
+    AlignedReallocFn,           // aligned_realloc_function
+    AlignedReallocUncheckedFn,  // aligned_realloc_unchecked_function
+    AlignedFreeFn,              // aligned_free_function
+    nullptr                     // next
+};
+#endif  // PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
 
 // Specialization of DispatcherImpl in case we have no observers to notify. In
 // this special case we return a set of null pointers as the Dispatcher must not
@@ -348,10 +354,10 @@ template <>
 struct DispatcherImpl<> {
   static DispatchData GetNotificationHooks(std::tuple<> /*observers*/) {
     return DispatchData()
-#if BUILDFLAG(USE_PARTITION_ALLOC)
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC)
         .SetAllocationObserverHooks(nullptr, nullptr)
 #endif
-#if BUILDFLAG(USE_ALLOCATOR_SHIM)
+#if PA_BUILDFLAG(USE_ALLOCATOR_SHIM)
         .SetAllocatorDispatch(nullptr)
 #endif
         ;

src/base/allocator/dispatcher/internal/tools.h

@@ -26,4 +26,4 @@ struct IsValidObserver {
 
 }  // namespace base::allocator::dispatcher::internal
 
-#endif  // BASE_ALLOCATOR_DISPATCHER_INTERNAL_DISPATCHER_H_
+#endif  // BASE_ALLOCATOR_DISPATCHER_INTERNAL_TOOLS_H_

src/base/allocator/dispatcher/memory_tagging.cc

@@ -0,0 +1,20 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/allocator/dispatcher/memory_tagging.h"
+
+namespace base::allocator::dispatcher {
+static_assert(
+    MTEMode::kUndefined ==
+    ConvertToMTEMode(partition_alloc::TagViolationReportingMode::kUndefined));
+static_assert(
+    MTEMode::kDisabled ==
+    ConvertToMTEMode(partition_alloc::TagViolationReportingMode::kDisabled));
+static_assert(
+    MTEMode::kSynchronous ==
+    ConvertToMTEMode(partition_alloc::TagViolationReportingMode::kSynchronous));
+static_assert(MTEMode::kAsynchronous ==
+              ConvertToMTEMode(
+                  partition_alloc::TagViolationReportingMode::kAsynchronous));
+}  // namespace base::allocator::dispatcher

src/base/allocator/dispatcher/memory_tagging.h

@@ -0,0 +1,42 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_ALLOCATOR_DISPATCHER_MEMORY_TAGGING_H_
+#define BASE_ALLOCATOR_DISPATCHER_MEMORY_TAGGING_H_
+
+#include "partition_alloc/tagging.h"
+
+namespace base::allocator::dispatcher {
+// The various modes of Arm's MTE extension. The enum values should match their
+// pendants in partition_alloc::TagViolationReportingMode, otherwise the below
+// conversion function would involve a translation table or conditional jumps.
+enum class MTEMode {
+  // Default settings
+  kUndefined,
+  // MTE explicitly disabled.
+  kDisabled,
+  // Precise tag violation reports, higher overhead. Good for unittests
+  // and security critical threads.
+  kSynchronous,
+  // Imprecise tag violation reports (async mode). Lower overhead.
+  kAsynchronous,
+};
+
+constexpr MTEMode ConvertToMTEMode(
+    partition_alloc::TagViolationReportingMode pa_mte_reporting_mode) {
+  switch (pa_mte_reporting_mode) {
+    case partition_alloc::TagViolationReportingMode::kUndefined:
+      return MTEMode::kUndefined;
+    case partition_alloc::TagViolationReportingMode::kDisabled:
+      return MTEMode::kDisabled;
+    case partition_alloc::TagViolationReportingMode::kSynchronous:
+      return MTEMode::kSynchronous;
+    case partition_alloc::TagViolationReportingMode::kAsynchronous:
+      return MTEMode::kAsynchronous;
+  }
+}
+
+}  // namespace base::allocator::dispatcher
+
+#endif  // BASE_ALLOCATOR_DISPATCHER_MEMORY_TAGGING_H_

src/base/allocator/dispatcher/notification_data.h

@@ -0,0 +1,110 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_ALLOCATOR_DISPATCHER_NOTIFICATION_DATA_H_
+#define BASE_ALLOCATOR_DISPATCHER_NOTIFICATION_DATA_H_
+
+#include <cstdint>
+
+#include "base/allocator/dispatcher/memory_tagging.h"
+#include "base/allocator/dispatcher/subsystem.h"
+#include "base/base_export.h"
+#include "partition_alloc/buildflags.h"
+
+namespace base::allocator::dispatcher {
+
+// Definitions of the parameter structures passed to the observer hooks. They
+// are similar to the structures defined by PartitionAllocator but provide
+// further information.
+
+// The notification data for the allocation path.
+class BASE_EXPORT AllocationNotificationData {
+ public:
+  constexpr AllocationNotificationData(void* address,
+                                       size_t size,
+                                       const char* type_name,
+                                       AllocationSubsystem allocation_subsystem)
+      : address_(address),
+        size_(size),
+        type_name_(type_name),
+        allocation_subsystem_(allocation_subsystem) {}
+
+  constexpr void* address() const { return address_; }
+
+  constexpr size_t size() const { return size_; }
+
+  constexpr const char* type_name() const { return type_name_; }
+
+  constexpr AllocationSubsystem allocation_subsystem() const {
+    return allocation_subsystem_;
+  }
+
+  // In the allocation observer path, it's interesting which reporting mode is
+  // enabled.
+#if PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+  constexpr AllocationNotificationData& SetMteReportingMode(MTEMode mode) {
+    mte_reporting_mode_ = mode;
+    return *this;
+  }
+#endif  // PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+
+  constexpr MTEMode mte_reporting_mode() const {
+#if PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+    return mte_reporting_mode_;
+#else
+    return MTEMode::kUndefined;
+#endif  // PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+  }
+
+ private:
+  void* address_ = nullptr;
+  size_t size_ = 0;
+  const char* type_name_ = nullptr;
+#if PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+  MTEMode mte_reporting_mode_ = MTEMode::kUndefined;
+#endif  // PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+  AllocationSubsystem allocation_subsystem_;
+};
+
+// The notification data for the free path.
+class BASE_EXPORT FreeNotificationData {
+ public:
+  constexpr explicit FreeNotificationData(
+      void* address,
+      AllocationSubsystem allocation_subsystem)
+      : address_(address), allocation_subsystem_(allocation_subsystem) {}
+
+  constexpr void* address() const { return address_; }
+
+  constexpr AllocationSubsystem allocation_subsystem() const {
+    return allocation_subsystem_;
+  }
+
+  // In the free observer path, it's interesting which reporting mode is
+  // enabled.
+#if PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+  constexpr FreeNotificationData& SetMteReportingMode(MTEMode mode) {
+    mte_reporting_mode_ = mode;
+    return *this;
+  }
+#endif  // PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+
+  constexpr MTEMode mte_reporting_mode() const {
+#if PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+    return mte_reporting_mode_;
+#else
+    return MTEMode::kUndefined;
+#endif  // PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+  }
+
+ private:
+  void* address_ = nullptr;
+#if PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+  MTEMode mte_reporting_mode_ = MTEMode::kUndefined;
+#endif  // PA_BUILDFLAG(HAS_MEMORY_TAGGING)
+  AllocationSubsystem allocation_subsystem_;
+};
+
+}  // namespace base::allocator::dispatcher
+#endif  // BASE_ALLOCATOR_DISPATCHER_NOTIFICATION_DATA_H_

src/base/allocator/dispatcher/reentry_guard.cc

@@ -6,6 +6,8 @@
 
 #include "base/check.h"
 #include "base/compiler_specific.h"
+#include "base/debug/crash_logging.h"
+#include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 
 #if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_ANDROID)
@@ -15,15 +17,25 @@
 namespace base::allocator::dispatcher {
 
 #if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_ANDROID)
-pthread_key_t ReentryGuard::entered_key_ = 0;
+// pthread_key_t has different signedness on Mac and Android. Store the null
+// value in a strongly-typed constant to avoid "comparison of integers of
+// different signs" warnings when comparing with 0.
+constexpr pthread_key_t kNullKey = 0;
+
+pthread_key_t ReentryGuard::entered_key_ = kNullKey;
 
 void ReentryGuard::InitTLSSlot() {
-  if (entered_key_ == 0) {
+  if (entered_key_ == kNullKey) {
     int error = pthread_key_create(&entered_key_, nullptr);
     CHECK(!error);
+    // Touch the TLS slot immediately to force any allocations.
+    // TODO(crbug.com/40062835): Use this technique to avoid allocations
+    // in PoissonAllocationSampler::ScopedMuteThreadSamples, which will make
+    // ReentryGuard redundant.
+    pthread_setspecific(entered_key_, nullptr);
   }
 
-  DCHECK(entered_key_ != 0);
+  DCHECK_NE(entered_key_, kNullKey);
 }
 
 #else
@@ -31,4 +43,19 @@ void ReentryGuard::InitTLSSlot() {
 void ReentryGuard::InitTLSSlot() {}
 
 #endif
+
+void ReentryGuard::RecordTLSSlotToCrashKey() {
+  // Record the key in crash dumps to detect when it's higher than 32
+  // (PTHREAD_KEY_2NDLEVEL_SIZE).
+  // TODO(crbug.com/40062835): Remove this after diagnosing reentry crashes.
+  static auto* const crash_key = base::debug::AllocateCrashKeyString(
+      "reentry_guard_tls_slot", base::debug::CrashKeySize::Size32);
+
+#if BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_ANDROID)
+  base::debug::SetCrashKeyString(crash_key, base::NumberToString(entered_key_));
+#else
+  base::debug::SetCrashKeyString(crash_key, "unused");
+#endif
+}
+
 }  // namespace base::allocator::dispatcher

src/base/allocator/dispatcher/reentry_guard.h

@@ -23,26 +23,36 @@ namespace base::allocator::dispatcher {
 // twice. The scoped guard allows us to detect that.
 //
 // Besides that the implementations of thread_local on macOS and Android
-// seem to allocate memory lazily on the first access to thread_local variables.
-// Make use of pthread TLS instead of C++ thread_local there.
+// seem to allocate memory lazily on the first access to thread_local variables
+// (and on Android at least thread_local is implemented on top of pthread so is
+// strictly worse for performance). Make use of pthread TLS instead of C++
+// thread_local there.
 struct BASE_EXPORT ReentryGuard {
-  ReentryGuard() : allowed_(!pthread_getspecific(entered_key_)) {
+  ALWAYS_INLINE ReentryGuard() : allowed_(!pthread_getspecific(entered_key_)) {
     pthread_setspecific(entered_key_, reinterpret_cast<void*>(true));
   }
 
-  ~ReentryGuard() {
-    if (LIKELY(allowed_))
+  ALWAYS_INLINE ~ReentryGuard() {
+    if (allowed_) [[likely]] {
       pthread_setspecific(entered_key_, nullptr);
+    }
   }
 
   explicit operator bool() const noexcept { return allowed_; }
 
-  // This function must be called in very early of the process start-up in
-  // order to acquire a low TLS slot number because glibc TLS implementation
-  // will require a malloc call to allocate storage for a higher slot number
-  // (>= PTHREAD_KEY_2NDLEVEL_SIZE == 32).  c.f. heap_profiling::InitTLSSlot.
+  // This function must be called before installing any allocator hooks because
+  // some TLS implementations may allocate (eg. glibc will require a malloc call
+  // to allocate storage for a higher slot number (>= PTHREAD_KEY_2NDLEVEL_SIZE
+  // == 32). This touches the thread-local storage so that any malloc happens
+  // before installing the hooks.
   static void InitTLSSlot();
 
+  // InitTLSSlot() is called before crash keys are available. At some point
+  // after SetCrashKeyImplementation() is called, this function should be
+  // called to record `entered_key_` to a crash key for debugging. This may
+  // allocate so it must not be called from inside an allocator hook.
+  static void RecordTLSSlotToCrashKey();
+
  private:
   static pthread_key_t entered_key_;
   const bool allowed_;
@@ -56,6 +66,7 @@ struct [[maybe_unused]] BASE_EXPORT ReentryGuard {
   constexpr explicit operator bool() const noexcept { return true; }
 
   static void InitTLSSlot();
+  static void RecordTLSSlotToCrashKey();
 };
 
 #endif

src/base/allocator/dispatcher/subsystem.h

@@ -14,8 +14,14 @@ enum class AllocationSubsystem {
   // Allocation is handled by PartitionAllocator.
   kPartitionAllocator = 1,
   // Allocation is handled by AllocatorShims.
-  kAllocatorShim = 2
+  kAllocatorShim = 2,
+  // Represents a simulated allocation event during testing and is used to
+  // filter out these allocations from real ones.
+  //
+  // Included for backward compatibility, this value becomes obsolete once the
+  // old allocation hooks are removed from PoissonAllocationSampler.
+  kManualForTesting = 3,
 };
 }  // namespace base::allocator::dispatcher
 
-#endif  // BASE_ALLOCATOR_DISPATCHER_SUBSYSTEM_H_
+#endif  // BASE_ALLOCATOR_DISPATCHER_SUBSYSTEM_H_

src/base/allocator/dispatcher/testing/dispatcher_test.h

@@ -24,4 +24,4 @@ struct DispatcherTest : public ::testing::Test {
 
 }  // namespace base::allocator::dispatcher::testing
 
-#endif  // BASE_ALLOCATOR_DISPATCHER_TESTING_DISPATCHER_TEST_H_
+#endif  // BASE_ALLOCATOR_DISPATCHER_TESTING_DISPATCHER_TEST_H_

src/base/allocator/dispatcher/testing/observer_mock.h

@@ -5,12 +5,13 @@
 #ifndef BASE_ALLOCATOR_DISPATCHER_TESTING_OBSERVER_MOCK_H_
 #define BASE_ALLOCATOR_DISPATCHER_TESTING_OBSERVER_MOCK_H_
 
-#include "base/allocator/dispatcher/subsystem.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
-#include <cstddef>
+namespace base::allocator::dispatcher {
+class AllocationNotificationData;
+class FreeNotificationData;
 
-namespace base::allocator::dispatcher::testing {
+namespace testing {
 
 // ObserverMock is a small mock class based on GoogleMock.
 // It complies to the interface enforced by the dispatcher. The template
@@ -19,14 +20,14 @@ template <typename T = void>
 struct ObserverMock {
   MOCK_METHOD(void,
               OnAllocation,
-              (void* address,
-               size_t size,
-               AllocationSubsystem sub_system,
-               const char* type_name),
+              (const AllocationNotificationData& notification_data),
+              ());
+  MOCK_METHOD(void,
+              OnFree,
+              (const FreeNotificationData& notification_data),
               ());
-  MOCK_METHOD(void, OnFree, (void* address), ());
 };
+}  // namespace testing
+}  // namespace base::allocator::dispatcher
 
-}  // namespace base::allocator::dispatcher::testing
-
-#endif  // BASE_ALLOCATOR_DISPATCHER_TESTING_OBSERVER_MOCK_H_
+#endif  // BASE_ALLOCATOR_DISPATCHER_TESTING_OBSERVER_MOCK_H_

src/base/allocator/dispatcher/testing/tools.h

@@ -47,4 +47,4 @@ CreateTupleOfPointers(std::array<Type, Size>& items) {
 
 }  // namespace base::allocator::dispatcher::testing
 
-#endif
+#endif  // BASE_ALLOCATOR_DISPATCHER_TESTING_TOOLS_H_

src/base/allocator/dispatcher/tls.cc

@@ -4,19 +4,64 @@
 
 #include "base/allocator/dispatcher/tls.h"
 
-#if USE_LOCAL_TLS_EMULATION()
+#include <string_view>
 
-#include "base/check.h"
-#include "base/dcheck_is_on.h"
-#include "base/immediate_crash.h"
+#if USE_LOCAL_TLS_EMULATION()
 
 #include <sys/mman.h>
 
+#include "base/check.h"
+#include "base/dcheck_is_on.h"
+#include "base/debug/crash_logging.h"
+#include "base/immediate_crash.h"
+#include "build/build_config.h"
+
+#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX)
+#include <sys/prctl.h>
+#endif
+
 namespace base::allocator::dispatcher::internal {
+namespace {
+base::debug::CrashKeySize GetCrashKeySize(const std::string& crash_key_name) {
+  if (std::size(crash_key_name) <= 32ul) {
+    return base::debug::CrashKeySize::Size32;
+  }
+  if (std::size(crash_key_name) <= 64ul) {
+    return base::debug::CrashKeySize::Size64;
+  }
+  if (std::size(crash_key_name) <= 256ul) {
+    return base::debug::CrashKeySize::Size256;
+  }
+  CHECK(std::size(crash_key_name) <= 1024ul);
+
+  return base::debug::CrashKeySize::Size1024;
+}
+
+#if DCHECK_IS_ON()
+void Swap(std::atomic_bool& lh_op, std::atomic_bool& rh_op) {
+  auto lh_op_value = lh_op.load(std::memory_order_relaxed);
+  auto rh_op_value = rh_op.load(std::memory_order_relaxed);
+
+  CHECK(lh_op.compare_exchange_strong(lh_op_value, rh_op_value));
+  CHECK(rh_op.compare_exchange_strong(rh_op_value, lh_op_value));
+}
+#endif
+}  // namespace
 
 void* MMapAllocator::AllocateMemory(size_t size_in_bytes) {
   void* const mmap_res = mmap(nullptr, size_in_bytes, PROT_READ | PROT_WRITE,
                               MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_LINUX)
+#if defined(PR_SET_VMA) && defined(PR_SET_VMA_ANON_NAME)
+  if (mmap_res != MAP_FAILED) {
+    // Allow the anonymous memory region allocated by mmap(MAP_ANONYMOUS) to
+    // be identified in /proc/$PID/smaps.  This helps improve visibility into
+    // Chromium's memory usage on Android.
+    prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, mmap_res, size_in_bytes,
+          "tls-mmap-allocator");
+  }
+#endif
+#endif
 
   return (mmap_res != MAP_FAILED) ? mmap_res : nullptr;
 }
@@ -27,8 +72,31 @@ bool MMapAllocator::FreeMemoryForTesting(void* pointer_to_allocated,
   return (munmap_res == 0);
 }
 
+PThreadTLSSystem::PThreadTLSSystem() = default;
+
+PThreadTLSSystem::PThreadTLSSystem(PThreadTLSSystem&& other) {
+  std::swap(crash_key_, other.crash_key_);
+  std::swap(data_access_key_, other.data_access_key_);
+
+#if DCHECK_IS_ON()
+  Swap(initialized_, other.initialized_);
+#endif
+}
+
+PThreadTLSSystem& PThreadTLSSystem::operator=(PThreadTLSSystem&& other) {
+  std::swap(crash_key_, other.crash_key_);
+  std::swap(data_access_key_, other.data_access_key_);
+
+#if DCHECK_IS_ON()
+  Swap(initialized_, other.initialized_);
+#endif
+
+  return *this;
+}
+
 bool PThreadTLSSystem::Setup(
-    OnThreadTerminationFunction thread_termination_function) {
+    OnThreadTerminationFunction thread_termination_function,
+    std::string_view instance_id) {
 #if DCHECK_IS_ON()
   // Initialize must happen outside of the allocation path. Therefore, it is
   // secure to verify with DCHECK.
@@ -45,10 +113,31 @@ bool PThreadTLSSystem::Setup(
   // However, we strongly recommend to setup the TLS system as early as possible
   // to avoid exceeding this limit.
 
+  // Some crashes might be caused by the initialization being performed too late
+  // and running into the problems mentioned above. Since there's no way to
+  // handle this issue programmatically, we include the key into the crashpad
+  // report to allow for later inspection.
+  std::string crash_key_name = "tls_system-";
+  crash_key_name += instance_id;
+
+  crash_key_ = base::debug::AllocateCrashKeyString(
+      crash_key_name.c_str(), GetCrashKeySize(crash_key_name));
+  base::debug::SetCrashKeyString(crash_key_,
+                                 base::NumberToString(data_access_key_));
+
   return (0 == key_create_res);
 }
 
 bool PThreadTLSSystem::TearDownForTesting() {
+#if DCHECK_IS_ON()
+  // TearDownForTesting must happen outside of the allocation path. Therefore,
+  // it is secure to verify with DCHECK.
+  DCHECK(initialized_.exchange(false, std::memory_order_acq_rel));
+#endif
+
+  base::debug::ClearCrashKeyString(crash_key_);
+  crash_key_ = nullptr;
+
   auto const key_delete_res = pthread_key_delete(data_access_key_);
   return (0 == key_delete_res);
 }
@@ -75,4 +164,4 @@ bool PThreadTLSSystem::SetThreadSpecificData(void* data) {
 
 }  // namespace base::allocator::dispatcher::internal
 
-#endif  // USE_LOCAL_TLS_EMULATION()
+#endif  // USE_LOCAL_TLS_EMULATION()

src/base/allocator/dispatcher/tls.h

@@ -5,6 +5,8 @@
 #ifndef BASE_ALLOCATOR_DISPATCHER_TLS_H_
 #define BASE_ALLOCATOR_DISPATCHER_TLS_H_
 
+#include <string_view>
+
 #include "build/build_config.h"
 
 #if BUILDFLAG(IS_POSIX)  // the current allocation mechanism (mmap) and TLS
@@ -15,18 +17,21 @@
 #endif
 
 #if USE_LOCAL_TLS_EMULATION()
-#include "base/allocator/partition_allocator/partition_alloc_constants.h"
-#include "base/base_export.h"
-#include "base/check.h"
-#include "base/compiler_specific.h"
-#include "base/dcheck_is_on.h"
+#include <pthread.h>
 
 #include <algorithm>
 #include <atomic>
+#include <functional>
 #include <memory>
 #include <mutex>
 
-#include <pthread.h>
+#include "base/base_export.h"
+#include "base/check.h"
+#include "base/compiler_specific.h"
+
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC)
+#include "partition_alloc/partition_alloc_constants.h"  // nogncheck
+#endif
 
 #if HAS_FEATURE(thread_sanitizer)
 #define DISABLE_TSAN_INSTRUMENTATION __attribute__((no_sanitize("thread")))
@@ -34,6 +39,29 @@
 #define DISABLE_TSAN_INSTRUMENTATION
 #endif
 
+#define STR_HELPER(x) #x
+#define STR(x) STR_HELPER(x)
+
+// Verify that a condition holds and cancel the process in case it doesn't. The
+// functionality is similar to RAW_CHECK but includes more information in the
+// logged messages. It is non allocating to prevent recursions.
+#define TLS_RAW_CHECK(error_message, condition) \
+  TLS_RAW_CHECK_IMPL(error_message, condition, __FILE__, __LINE__)
+
+#define TLS_RAW_CHECK_IMPL(error_message, condition, file, line)        \
+  do {                                                                  \
+    if (!(condition)) {                                                 \
+      constexpr const char* message =                                   \
+          "TLS System: " error_message " Failed condition '" #condition \
+          "' in (" file "@" STR(line) ").\n";                           \
+      ::logging::RawCheckFailure(message);                              \
+    }                                                                   \
+  } while (0)
+
+namespace base::debug {
+struct CrashKeyString;
+}
+
 namespace base::allocator::dispatcher {
 namespace internal {
 
@@ -51,6 +79,8 @@ struct BASE_EXPORT MMapAllocator {
       partition_alloc::PartitionPageSize();
 #elif BUILDFLAG(IS_APPLE)
   constexpr static size_t AllocationChunkSize = 16384;
+#elif BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_64_BITS)
+  constexpr static size_t AllocationChunkSize = 16384;
 #elif BUILDFLAG(IS_LINUX) && defined(ARCH_CPU_ARM64)
   constexpr static size_t AllocationChunkSize = 16384;
 #else
@@ -72,11 +102,20 @@ using OnThreadTerminationFunction = void (*)(void*);
 
 // The TLS system used by default for the thread local storage. It stores and
 // retrieves thread specific data pointers.
-struct BASE_EXPORT PThreadTLSSystem {
+class BASE_EXPORT PThreadTLSSystem {
+ public:
+  PThreadTLSSystem();
+
+  PThreadTLSSystem(const PThreadTLSSystem&) = delete;
+  PThreadTLSSystem(PThreadTLSSystem&&);
+  PThreadTLSSystem& operator=(const PThreadTLSSystem&) = delete;
+  PThreadTLSSystem& operator=(PThreadTLSSystem&&);
+
   // Initialize the TLS system to store a data set for different threads.
   // @param thread_termination_function An optional function which will be
   // invoked upon termination of a thread.
-  bool Setup(OnThreadTerminationFunction thread_termination_function);
+  bool Setup(OnThreadTerminationFunction thread_termination_function,
+             std::string_view instance_id);
   // Tear down the TLS system. After completing tear down, the thread
   // termination function passed to Setup will not be invoked anymore.
   bool TearDownForTesting();
@@ -89,6 +128,7 @@ struct BASE_EXPORT PThreadTLSSystem {
   bool SetThreadSpecificData(void* data);
 
  private:
+  base::debug::CrashKeyString* crash_key_ = nullptr;
   pthread_key_t data_access_key_ = 0;
 #if DCHECK_IS_ON()
   // From POSIX standard at https://www.open-std.org/jtc1/sc22/open/n4217.pdf:
@@ -163,16 +203,21 @@ template <typename PayloadType,
           size_t AllocationChunkSize,
           bool IsDestructibleForTesting>
 struct ThreadLocalStorage {
-  ThreadLocalStorage() : root_(AllocateAndInitializeChunk()) { Initialize(); }
+  explicit ThreadLocalStorage(std::string_view instance_id)
+      : root_(AllocateAndInitializeChunk()) {
+    Initialize(instance_id);
+  }
 
   // Create a new instance of |ThreadLocalStorage| using the passed allocator
   // and TLS system. This initializes the underlying TLS system and creates the
   // first chunk of data.
-  ThreadLocalStorage(AllocatorType allocator, TLSSystemType tlsSystem)
+  ThreadLocalStorage(std::string_view instance_id,
+                     AllocatorType allocator,
+                     TLSSystemType tls_system)
       : allocator_(std::move(allocator)),
-        tls_system_(std::move(tlsSystem)),
+        tls_system_(std::move(tls_system)),
         root_(AllocateAndInitializeChunk()) {
-    Initialize();
+    Initialize(instance_id);
   }
 
   // Deletes an instance of |ThreadLocalStorage| and delete all the data chunks
@@ -198,17 +243,21 @@ struct ThreadLocalStorage {
 
   // Get the data item for the current thread. If no data is registered so far,
   // find a free item in the chunks and register it for the current thread.
-  DISABLE_TSAN_INSTRUMENTATION PayloadType* GetThreadLocalData() {
+  PayloadType* GetThreadLocalData() {
     auto& tls_system = dereference(tls_system_);
 
     auto* slot = static_cast<SingleSlot*>(tls_system.GetThreadSpecificData());
 
-    if (UNLIKELY(slot == nullptr)) {
+    if (slot == nullptr) [[unlikely]] {
       slot = FindAndAllocateFreeSlot(root_.load(std::memory_order_relaxed));
-      CHECK(tls_system.SetThreadSpecificData(slot));
+
+      // We might be called in the course of handling a memory allocation. We do
+      // not use CHECK since they might allocate and cause a recursion.
+      TLS_RAW_CHECK("Failed to set thread specific data.",
+                    tls_system.SetThreadSpecificData(slot));
 
       // Reset the content to wipe out any previous data.
-      slot->item = {};
+      Reset(slot->item);
     }
 
     return &(slot->item);
@@ -305,27 +354,34 @@ struct ThreadLocalStorage {
     // SingleSlot and reset the is_used flag.
     auto* const slot = static_cast<SingleSlot*>(data);
 
-    DCHECK(slot && slot->is_used.test_and_set());
+    // We might be called in the course of handling a memory allocation.
+    // Therefore, do not use CHECK since it might allocate and cause a
+    // recursion.
+    TLS_RAW_CHECK("Received an invalid slot.",
+                  slot && slot->is_used.test_and_set());
 
     slot->is_used.clear(std::memory_order_relaxed);
   }
 
   // Perform common initialization during construction of an instance.
-  void Initialize() {
+  void Initialize(std::string_view instance_id) {
     // The constructor must be called outside of the allocation path. Therefore,
     // it is secure to verify with CHECK.
 
     // Passing MarkSlotAsFree as thread_termination_function we ensure the
     // slot/item assigned to the finished thread will be returned to the pool of
     // unused items.
-    CHECK(dereference(tls_system_).Setup(&MarkSlotAsFree));
+    CHECK(dereference(tls_system_).Setup(&MarkSlotAsFree, instance_id));
   }
 
   Chunk* AllocateAndInitializeChunk() {
     void* const uninitialized_memory =
         dereference(allocator_).AllocateMemory(sizeof(Chunk));
 
-    CHECK(uninitialized_memory);
+    // We might be called in the course of handling a memory allocation. We do
+    // not use CHECK since they might allocate and cause a recursion.
+    TLS_RAW_CHECK("Failed to allocate memory for new chunk.",
+                  uninitialized_memory != nullptr);
 
     return new (uninitialized_memory) Chunk{};
   }
@@ -333,6 +389,8 @@ struct ThreadLocalStorage {
   void FreeAndDeallocateChunkForTesting(Chunk* chunk_to_erase) {
     chunk_to_erase->~Chunk();
 
+    // FreeAndDeallocateChunkForTesting must be called outside of the allocation
+    // path. Therefore, it is secure to verify with CHECK.
     CHECK(dereference(allocator_)
               .FreeMemoryForTesting(chunk_to_erase, sizeof(Chunk)));
   }
@@ -391,6 +449,12 @@ struct ThreadLocalStorage {
     }
   }
 
+  // Reset a single item to its default value.
+  // Since items are re-used, they may be accessed from different threads,
+  // causing TSan to trigger. Therefore, the reset is exempt from TSan
+  // instrumentation.
+  DISABLE_TSAN_INSTRUMENTATION void Reset(PayloadType& item) { item = {}; }
+
   AllocatorType allocator_;
   TLSSystemType tls_system_;
   std::atomic<Chunk*> const root_;
@@ -414,5 +478,10 @@ using ThreadLocalStorage =
 
 }  // namespace base::allocator::dispatcher
 
+#undef TLS_RAW_CHECK_IMPL
+#undef TLS_RAW_CHECK
+#undef STR
+#undef STR_HELPER
+
 #endif  // USE_LOCAL_TLS_EMULATION()
 #endif  // BASE_ALLOCATOR_DISPATCHER_TLS_H_

src/base/allocator/early_zone_registration_apple.cc

@@ -0,0 +1,266 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/allocator/early_zone_registration_apple.h"
+
+#include <mach/mach.h>
+#include <malloc/malloc.h>
+
+#include "partition_alloc/buildflags.h"
+#include "partition_alloc/shim/early_zone_registration_constants.h"
+
+// BASE_EXPORT tends to be defined as soon as anything from //base is included.
+#if defined(BASE_EXPORT)
+#error "This file cannot depend on //base"
+#endif
+
+namespace partition_alloc {
+
+#if !PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
+
+void EarlyMallocZoneRegistration() {}
+void AllowDoublePartitionAllocZoneRegistration() {}
+
+#else
+
+extern "C" {
+// abort_report_np() records the message in a special section that both the
+// system CrashReporter and Crashpad collect in crash reports. See also in
+// chrome_exe_main_mac.cc.
+void abort_report_np(const char* fmt, ...);
+}
+
+namespace {
+
+malloc_zone_t* GetDefaultMallocZone() {
+  // malloc_default_zone() does not return... the default zone, but the
+  // initial one. The default one is the first element of the default zone
+  // array.
+  unsigned int zone_count = 0;
+  vm_address_t* zones = nullptr;
+  kern_return_t result = malloc_get_all_zones(
+      mach_task_self(), /*reader=*/nullptr, &zones, &zone_count);
+  if (result != KERN_SUCCESS) {
+    abort_report_np("Cannot enumerate malloc() zones");
+  }
+  return reinterpret_cast<malloc_zone_t*>(zones[0]);
+}
+
+}  // namespace
+
+void EarlyMallocZoneRegistration() {
+  // Must have static storage duration, as raw pointers are passed to
+  // libsystem_malloc.
+  static malloc_zone_t g_delegating_zone;
+  static malloc_introspection_t g_delegating_zone_introspect;
+  static malloc_zone_t* g_default_zone;
+
+  // Make sure that the default zone is instantiated.
+  malloc_zone_t* purgeable_zone = malloc_default_purgeable_zone();
+
+  g_default_zone = GetDefaultMallocZone();
+
+  // The delegating zone:
+  // - Forwards all allocations to the existing default zone
+  // - Does *not* claim to own any memory, meaning that it will always be
+  //   skipped in free() in libsystem_malloc.dylib.
+  //
+  // This is a temporary zone, until it gets replaced by PartitionAlloc, inside
+  // the main library. Since the main library depends on many external
+  // libraries, we cannot install PartitionAlloc as the default zone without
+  // concurrency issues.
+  //
+  // Instead, what we do is here, while the process is single-threaded:
+  // - Register the delegating zone as the default one.
+  // - Set the original (libsystem_malloc's) one as the second zone
+  //
+  // Later, when PartitionAlloc initializes, we replace the default (delegating)
+  // zone with ours. The end state is:
+  // 1. PartitionAlloc zone
+  // 2. libsystem_malloc zone
+
+  // Set up of the delegating zone. Note that it doesn't just forward calls to
+  // the default zone. This is because the system zone's malloc_zone_t pointer
+  // actually points to a larger struct, containing allocator metadata. So if we
+  // pass as the first parameter the "simple" delegating zone pointer, then we
+  // immediately crash inside the system zone functions. So we need to replace
+  // the zone pointer as well.
+  //
+  // Calls fall into 4 categories:
+  // - Allocation calls: forwarded to the real system zone
+  // - "Is this pointer yours" calls: always answer no
+  // - free(): Should never be called, but is in practice, see comments below.
+  // - Diagnostics and debugging: these are typically called for every
+  //   zone. They are no-ops for us, as we don't want to double-count, or lock
+  //   the data structures of the real zone twice.
+
+  // Allocation: Forward to the real zone.
+  g_delegating_zone.malloc = [](malloc_zone_t* zone, size_t size) {
+    return g_default_zone->malloc(g_default_zone, size);
+  };
+  g_delegating_zone.calloc = [](malloc_zone_t* zone, size_t num_items,
+                                size_t size) {
+    return g_default_zone->calloc(g_default_zone, num_items, size);
+  };
+  g_delegating_zone.valloc = [](malloc_zone_t* zone, size_t size) {
+    return g_default_zone->valloc(g_default_zone, size);
+  };
+  g_delegating_zone.realloc = [](malloc_zone_t* zone, void* ptr, size_t size) {
+    return g_default_zone->realloc(g_default_zone, ptr, size);
+  };
+  g_delegating_zone.batch_malloc = [](malloc_zone_t* zone, size_t size,
+                                      void** results, unsigned num_requested) {
+    return g_default_zone->batch_malloc(g_default_zone, size, results,
+                                        num_requested);
+  };
+  g_delegating_zone.memalign = [](malloc_zone_t* zone, size_t alignment,
+                                  size_t size) {
+    return g_default_zone->memalign(g_default_zone, alignment, size);
+  };
+
+  // Does ptr belong to this zone? Return value is != 0 if so.
+  g_delegating_zone.size = [](malloc_zone_t* zone, const void* ptr) -> size_t {
+    return 0;
+  };
+
+  // Free functions.
+  // The normal path for freeing memory is:
+  // 1. Try all zones in order, call zone->size(ptr)
+  // 2. If zone->size(ptr) != 0, call zone->free(ptr) (or free_definite_size)
+  // 3. If no zone matches, crash.
+  //
+  // Since this zone always returns 0 in size() (see above), then zone->free()
+  // should never be called. Unfortunately, this is not the case, as some places
+  // in CoreFoundation call malloc_zone_free(zone, ptr) directly. So rather than
+  // crashing, forward the call. It's the caller's responsibility to use the
+  // same zone for free() as for the allocation (this is in the contract of
+  // malloc_zone_free()).
+  //
+  // However, note that the sequence of calls size() -> free() is not possible
+  // for this zone, as size() always returns 0.
+  g_delegating_zone.free = [](malloc_zone_t* zone, void* ptr) {
+    return g_default_zone->free(g_default_zone, ptr);
+  };
+  g_delegating_zone.free_definite_size = [](malloc_zone_t* zone, void* ptr,
+                                            size_t size) {
+    return g_default_zone->free_definite_size(g_default_zone, ptr, size);
+  };
+  g_delegating_zone.batch_free = [](malloc_zone_t* zone, void** to_be_freed,
+                                    unsigned num_to_be_freed) {
+    return g_default_zone->batch_free(g_default_zone, to_be_freed,
+                                      num_to_be_freed);
+  };
+#if PA_TRY_FREE_DEFAULT_IS_AVAILABLE
+  g_delegating_zone.try_free_default = [](malloc_zone_t* zone, void* ptr) {
+    return g_default_zone->try_free_default(g_default_zone, ptr);
+  };
+#endif
+
+  // Diagnostics and debugging.
+  //
+  // Do nothing to reduce memory footprint, the real
+  // zone will do it.
+  g_delegating_zone.pressure_relief = [](malloc_zone_t* zone,
+                                         size_t goal) -> size_t { return 0; };
+
+  // Introspection calls are not all optional, for instance locking and
+  // unlocking before/after fork() is not optional.
+  //
+  // Nothing to enumerate.
+  g_delegating_zone_introspect.enumerator =
+      [](task_t task, void*, unsigned type_mask, vm_address_t zone_address,
+         memory_reader_t reader,
+         vm_range_recorder_t recorder) -> kern_return_t {
+    return KERN_SUCCESS;
+  };
+  // Need to provide a real implementation, it is used for e.g. array sizing.
+  g_delegating_zone_introspect.good_size = [](malloc_zone_t* zone,
+                                              size_t size) {
+    return g_default_zone->introspect->good_size(g_default_zone, size);
+  };
+  // Nothing to do.
+  g_delegating_zone_introspect.check = [](malloc_zone_t* zone) -> boolean_t {
+    return true;
+  };
+  g_delegating_zone_introspect.print = [](malloc_zone_t* zone,
+                                          boolean_t verbose) {};
+  g_delegating_zone_introspect.log = [](malloc_zone_t*, void*) {};
+  // Do not forward the lock / unlock calls. Since the default zone is still
+  // there, we should not lock here, as it would lock the zone twice (all
+  // zones are locked before fork().). Rather, do nothing, since this fake
+  // zone does not need any locking.
+  g_delegating_zone_introspect.force_lock = [](malloc_zone_t* zone) {};
+  g_delegating_zone_introspect.force_unlock = [](malloc_zone_t* zone) {};
+  g_delegating_zone_introspect.reinit_lock = [](malloc_zone_t* zone) {};
+  // No stats.
+  g_delegating_zone_introspect.statistics = [](malloc_zone_t* zone,
+                                               malloc_statistics_t* stats) {};
+  // We are not locked.
+  g_delegating_zone_introspect.zone_locked =
+      [](malloc_zone_t* zone) -> boolean_t { return false; };
+  // Don't support discharge checking.
+  g_delegating_zone_introspect.enable_discharge_checking =
+      [](malloc_zone_t* zone) -> boolean_t { return false; };
+  g_delegating_zone_introspect.disable_discharge_checking =
+      [](malloc_zone_t* zone) {};
+  g_delegating_zone_introspect.discharge = [](malloc_zone_t* zone,
+                                              void* memory) {};
+
+  // Could use something lower to support fewer functions, but this is
+  // consistent with the real zone installed by PartitionAlloc.
+  g_delegating_zone.version = allocator_shim::kZoneVersion;
+  g_delegating_zone.introspect = &g_delegating_zone_introspect;
+  // This name is used in PartitionAlloc's initialization to determine whether
+  // it should replace the delegating zone.
+  g_delegating_zone.zone_name = allocator_shim::kDelegatingZoneName;
+
+  // Register puts the new zone at the end, unregister swaps the new zone with
+  // the last one.
+  // The zone array is, after these lines, in order:
+  // 1. |g_default_zone|...|g_delegating_zone|
+  // 2. |g_delegating_zone|...|  (no more default)
+  // 3. |g_delegating_zone|...|g_default_zone|
+  malloc_zone_register(&g_delegating_zone);
+  malloc_zone_unregister(g_default_zone);
+  malloc_zone_register(g_default_zone);
+
+  // Make sure that the purgeable zone is after the default one.
+  // Will make g_default_zone take the purgeable zone spot
+  malloc_zone_unregister(purgeable_zone);
+  // Add back the purgeable zone as the last one.
+  malloc_zone_register(purgeable_zone);
+
+  // Final configuration:
+  // |g_delegating_zone|...|g_default_zone|purgeable_zone|
+
+  // Sanity check.
+  if (GetDefaultMallocZone() != &g_delegating_zone) {
+    abort_report_np("Failed to install the delegating zone as default.");
+  }
+}
+
+void AllowDoublePartitionAllocZoneRegistration() {
+  unsigned int zone_count = 0;
+  vm_address_t* zones = nullptr;
+  kern_return_t result = malloc_get_all_zones(
+      mach_task_self(), /*reader=*/nullptr, &zones, &zone_count);
+  if (result != KERN_SUCCESS) {
+    abort_report_np("Cannot enumerate malloc() zones");
+  }
+
+  // If PartitionAlloc is one of the zones, *change* its name so that
+  // registration can happen multiple times. This works because zone
+  // registration only keeps a pointer to the struct, it does not copy the data.
+  for (unsigned int i = 0; i < zone_count; i++) {
+    malloc_zone_t* zone = reinterpret_cast<malloc_zone_t*>(zones[i]);
+    if (zone->zone_name &&
+        strcmp(zone->zone_name, allocator_shim::kPartitionAllocZoneName) == 0) {
+      zone->zone_name = "RenamedPartitionAlloc";
+      break;
+    }
+  }
+}
+
+#endif  // PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
+}  // namespace partition_alloc

src/base/allocator/early_zone_registration_apple.h

@@ -0,0 +1,29 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_ALLOCATOR_EARLY_ZONE_REGISTRATION_APPLE_H_
+#define BASE_ALLOCATOR_EARLY_ZONE_REGISTRATION_APPLE_H_
+
+// This is an Apple-only file, used to register PartitionAlloc's zone *before*
+// the process becomes multi-threaded.
+
+namespace partition_alloc {
+
+// Must be called *once*, *before* the process becomes multi-threaded.
+void EarlyMallocZoneRegistration();
+
+// Tricks the registration code to believe that PartitionAlloc was not already
+// registered. This allows a future library load to register PartitionAlloc's
+// zone as well, rather than bailing out.
+//
+// This is mutually exclusive with EarlyMallocZoneRegistration(), and should
+// ideally be removed. Indeed, by allowing two zones to be registered, we still
+// end up with a split heap, and more memory usage.
+//
+// This is a hack for https://crbug.com/1274236.
+void AllowDoublePartitionAllocZoneRegistration();
+
+}  // namespace partition_alloc
+
+#endif  // BASE_ALLOCATOR_EARLY_ZONE_REGISTRATION_APPLE_H_

src/base/allocator/early_zone_registration_mac.cc

@@ -1,262 +0,0 @@
-// Copyright 2021 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/allocator/early_zone_registration_mac.h"
-
-#include <mach/mach.h>
-#include <malloc/malloc.h>
-
-#include "base/allocator/buildflags.h"
-
-// BASE_EXPORT tends to be defined as soon as anything from //base is included.
-#if defined(BASE_EXPORT)
-#error "This file cannot depend on //base"
-#endif
-
-namespace partition_alloc {
-
-#if !BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
-
-void EarlyMallocZoneRegistration() {}
-void AllowDoublePartitionAllocZoneRegistration() {}
-
-#else
-
-extern "C" {
-// abort_report_np() records the message in a special section that both the
-// system CrashReporter and Crashpad collect in crash reports. See also in
-// chrome_exe_main_mac.cc.
-void abort_report_np(const char* fmt, ...);
-}
-
-namespace {
-
-malloc_zone_t* GetDefaultMallocZone() {
-  // malloc_default_zone() does not return... the default zone, but the
-  // initial one. The default one is the first element of the default zone
-  // array.
-  unsigned int zone_count = 0;
-  vm_address_t* zones = nullptr;
-  kern_return_t result =
-      malloc_get_all_zones(mach_task_self(), nullptr, &zones, &zone_count);
-  if (result != KERN_SUCCESS)
-    abort_report_np("Cannot enumerate malloc() zones");
-  return reinterpret_cast<malloc_zone_t*>(zones[0]);
-}
-
-}  // namespace
-
-void EarlyMallocZoneRegistration() {
-  // Must have static storage duration, as raw pointers are passed to
-  // libsystem_malloc.
-  static malloc_zone_t g_delegating_zone;
-  static malloc_introspection_t g_delegating_zone_introspect;
-  static malloc_zone_t* g_default_zone;
-
-  // Make sure that the default zone is instantiated.
-  malloc_zone_t* purgeable_zone = malloc_default_purgeable_zone();
-
-  g_default_zone = GetDefaultMallocZone();
-
-  // The delegating zone:
-  // - Forwards all allocations to the existing default zone
-  // - Does *not* claim to own any memory, meaning that it will always be
-  //   skipped in free() in libsystem_malloc.dylib.
-  //
-  // This is a temporary zone, until it gets replaced by PartitionAlloc, inside
-  // the main library. Since the main library depends on many external
-  // libraries, we cannot install PartitionAlloc as the default zone without
-  // concurrency issues.
-  //
-  // Instead, what we do is here, while the process is single-threaded:
-  // - Register the delegating zone as the default one.
-  // - Set the original (libsystem_malloc's) one as the second zone
-  //
-  // Later, when PartitionAlloc initializes, we replace the default (delegating)
-  // zone with ours. The end state is:
-  // 1. PartitionAlloc zone
-  // 2. libsystem_malloc zone
-
-  // Set up of the delegating zone. Note that it doesn't just forward calls to
-  // the default zone. This is because the system zone's malloc_zone_t pointer
-  // actually points to a larger struct, containing allocator metadata. So if we
-  // pass as the first parameter the "simple" delegating zone pointer, then we
-  // immediately crash inside the system zone functions. So we need to replace
-  // the zone pointer as well.
-  //
-  // Calls fall into 4 categories:
-  // - Allocation calls: forwarded to the real system zone
-  // - "Is this pointer yours" calls: always answer no
-  // - free(): Should never be called, but is in practice, see comments below.
-  // - Diagnostics and debugging: these are typically called for every
-  //   zone. They are no-ops for us, as we don't want to double-count, or lock
-  //   the data structures of the real zone twice.
-
-  // Allocation: Forward to the real zone.
-  g_delegating_zone.malloc = [](malloc_zone_t* zone, size_t size) {
-    return g_default_zone->malloc(g_default_zone, size);
-  };
-  g_delegating_zone.calloc = [](malloc_zone_t* zone, size_t num_items,
-                                size_t size) {
-    return g_default_zone->calloc(g_default_zone, num_items, size);
-  };
-  g_delegating_zone.valloc = [](malloc_zone_t* zone, size_t size) {
-    return g_default_zone->valloc(g_default_zone, size);
-  };
-  g_delegating_zone.realloc = [](malloc_zone_t* zone, void* ptr, size_t size) {
-    return g_default_zone->realloc(g_default_zone, ptr, size);
-  };
-  g_delegating_zone.batch_malloc = [](malloc_zone_t* zone, size_t size,
-                                      void** results, unsigned num_requested) {
-    return g_default_zone->batch_malloc(g_default_zone, size, results,
-                                        num_requested);
-  };
-  g_delegating_zone.memalign = [](malloc_zone_t* zone, size_t alignment,
-                                  size_t size) {
-    return g_default_zone->memalign(g_default_zone, alignment, size);
-  };
-
-  // Does ptr belong to this zone? Return value is != 0 if so.
-  g_delegating_zone.size = [](malloc_zone_t* zone, const void* ptr) -> size_t {
-    return 0;
-  };
-
-  // Free functions.
-  // The normal path for freeing memory is:
-  // 1. Try all zones in order, call zone->size(ptr)
-  // 2. If zone->size(ptr) != 0, call zone->free(ptr) (or free_definite_size)
-  // 3. If no zone matches, crash.
-  //
-  // Since this zone always returns 0 in size() (see above), then zone->free()
-  // should never be called. Unfortunately, this is not the case, as some places
-  // in CoreFoundation call malloc_zone_free(zone, ptr) directly. So rather than
-  // crashing, forward the call. It's the caller's responsibility to use the
-  // same zone for free() as for the allocation (this is in the contract of
-  // malloc_zone_free()).
-  //
-  // However, note that the sequence of calls size() -> free() is not possible
-  // for this zone, as size() always returns 0.
-  g_delegating_zone.free = [](malloc_zone_t* zone, void* ptr) {
-    return g_default_zone->free(g_default_zone, ptr);
-  };
-  g_delegating_zone.free_definite_size = [](malloc_zone_t* zone, void* ptr,
-                                            size_t size) {
-    return g_default_zone->free_definite_size(g_default_zone, ptr, size);
-  };
-  g_delegating_zone.batch_free = [](malloc_zone_t* zone, void** to_be_freed,
-                                    unsigned num_to_be_freed) {
-    return g_default_zone->batch_free(g_default_zone, to_be_freed,
-                                      num_to_be_freed);
-  };
-#if PA_TRY_FREE_DEFAULT_IS_AVAILABLE
-  g_delegating_zone.try_free_default = [](malloc_zone_t* zone, void* ptr) {
-    return g_default_zone->try_free_default(g_default_zone, ptr);
-  };
-#endif
-
-  // Diagnostics and debugging.
-  //
-  // Do nothing to reduce memory footprint, the real
-  // zone will do it.
-  g_delegating_zone.pressure_relief = [](malloc_zone_t* zone,
-                                         size_t goal) -> size_t { return 0; };
-
-  // Introspection calls are not all optional, for instance locking and
-  // unlocking before/after fork() is not optional.
-  //
-  // Nothing to enumerate.
-  g_delegating_zone_introspect.enumerator =
-      [](task_t task, void*, unsigned type_mask, vm_address_t zone_address,
-         memory_reader_t reader,
-         vm_range_recorder_t recorder) -> kern_return_t {
-    return KERN_SUCCESS;
-  };
-  // Need to provide a real implementation, it is used for e.g. array sizing.
-  g_delegating_zone_introspect.good_size = [](malloc_zone_t* zone,
-                                              size_t size) {
-    return g_default_zone->introspect->good_size(g_default_zone, size);
-  };
-  // Nothing to do.
-  g_delegating_zone_introspect.check = [](malloc_zone_t* zone) -> boolean_t {
-    return true;
-  };
-  g_delegating_zone_introspect.print = [](malloc_zone_t* zone,
-                                          boolean_t verbose) {};
-  g_delegating_zone_introspect.log = [](malloc_zone_t*, void*) {};
-  // Do not forward the lock / unlock calls. Since the default zone is still
-  // there, we should not lock here, as it would lock the zone twice (all
-  // zones are locked before fork().). Rather, do nothing, since this fake
-  // zone does not need any locking.
-  g_delegating_zone_introspect.force_lock = [](malloc_zone_t* zone) {};
-  g_delegating_zone_introspect.force_unlock = [](malloc_zone_t* zone) {};
-  g_delegating_zone_introspect.reinit_lock = [](malloc_zone_t* zone) {};
-  // No stats.
-  g_delegating_zone_introspect.statistics = [](malloc_zone_t* zone,
-                                               malloc_statistics_t* stats) {};
-  // We are not locked.
-  g_delegating_zone_introspect.zone_locked =
-      [](malloc_zone_t* zone) -> boolean_t { return false; };
-  // Don't support discharge checking.
-  g_delegating_zone_introspect.enable_discharge_checking =
-      [](malloc_zone_t* zone) -> boolean_t { return false; };
-  g_delegating_zone_introspect.disable_discharge_checking =
-      [](malloc_zone_t* zone) {};
-  g_delegating_zone_introspect.discharge = [](malloc_zone_t* zone,
-                                              void* memory) {};
-
-  // Could use something lower to support fewer functions, but this is
-  // consistent with the real zone installed by PartitionAlloc.
-  g_delegating_zone.version = kZoneVersion;
-  g_delegating_zone.introspect = &g_delegating_zone_introspect;
-  // This name is used in PartitionAlloc's initialization to determine whether
-  // it should replace the delegating zone.
-  g_delegating_zone.zone_name = kDelegatingZoneName;
-
-  // Register puts the new zone at the end, unregister swaps the new zone with
-  // the last one.
-  // The zone array is, after these lines, in order:
-  // 1. |g_default_zone|...|g_delegating_zone|
-  // 2. |g_delegating_zone|...|  (no more default)
-  // 3. |g_delegating_zone|...|g_default_zone|
-  malloc_zone_register(&g_delegating_zone);
-  malloc_zone_unregister(g_default_zone);
-  malloc_zone_register(g_default_zone);
-
-  // Make sure that the purgeable zone is after the default one.
-  // Will make g_default_zone take the purgeable zone spot
-  malloc_zone_unregister(purgeable_zone);
-  // Add back the purgeable zone as the last one.
-  malloc_zone_register(purgeable_zone);
-
-  // Final configuration:
-  // |g_delegating_zone|...|g_default_zone|purgeable_zone|
-
-  // Sanity check.
-  if (GetDefaultMallocZone() != &g_delegating_zone)
-    abort_report_np("Failed to install the delegating zone as default.");
-}
-
-void AllowDoublePartitionAllocZoneRegistration() {
-  unsigned int zone_count = 0;
-  vm_address_t* zones = nullptr;
-  kern_return_t result =
-      malloc_get_all_zones(mach_task_self(), nullptr, &zones, &zone_count);
-  if (result != KERN_SUCCESS)
-    abort_report_np("Cannot enumerate malloc() zones");
-
-  // If PartitionAlloc is one of the zones, *change* its name so that
-  // registration can happen multiple times. This works because zone
-  // registration only keeps a pointer to the struct, it does not copy the data.
-  for (unsigned int i = 0; i < zone_count; i++) {
-    malloc_zone_t* zone = reinterpret_cast<malloc_zone_t*>(zones[i]);
-    if (zone->zone_name &&
-        strcmp(zone->zone_name, kPartitionAllocZoneName) == 0) {
-      zone->zone_name = "RenamedPartitionAlloc";
-      break;
-    }
-  }
-}
-
-#endif  // BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
-}  // namespace partition_alloc

src/base/allocator/early_zone_registration_mac.h

@@ -1,45 +0,0 @@
-// Copyright 2021 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_ALLOCATOR_EARLY_ZONE_REGISTRATION_MAC_H_
-#define BASE_ALLOCATOR_EARLY_ZONE_REGISTRATION_MAC_H_
-
-// This is an Apple-only file, used to register PartitionAlloc's zone *before*
-// the process becomes multi-threaded.
-
-namespace partition_alloc {
-
-static constexpr char kDelegatingZoneName[] =
-    "DelegatingDefaultZoneForPartitionAlloc";
-static constexpr char kPartitionAllocZoneName[] = "PartitionAlloc";
-
-// Zone version. Determines which callbacks are set in the various malloc_zone_t
-// structs.
-#if (__MAC_OS_X_VERSION_MAX_ALLOWED >= 130000) || \
-    (__IPHONE_OS_VERSION_MAX_ALLOWED >= 160100)
-#define PA_TRY_FREE_DEFAULT_IS_AVAILABLE 1
-#endif
-#if PA_TRY_FREE_DEFAULT_IS_AVAILABLE
-constexpr int kZoneVersion = 13;
-#else
-constexpr int kZoneVersion = 9;
-#endif
-
-// Must be called *once*, *before* the process becomes multi-threaded.
-void EarlyMallocZoneRegistration();
-
-// Tricks the registration code to believe that PartitionAlloc was not already
-// registered. This allows a future library load to register PartitionAlloc's
-// zone as well, rather than bailing out.
-//
-// This is mutually exclusive with EarlyMallocZoneRegistation(), and should
-// ideally be removed. Indeed, by allowing two zones to be registered, we still
-// end up with a split heap, and more memory usage.
-//
-// This is a hack for crbug.com/1274236.
-void AllowDoublePartitionAllocZoneRegistration();
-
-}  // namespace partition_alloc
-
-#endif  // BASE_ALLOCATOR_EARLY_ZONE_REGISTRATION_H_

src/base/allocator/miracle_parameter.cc

@@ -0,0 +1,76 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/allocator/miracle_parameter.h"
+
+#include "base/command_line.h"
+#include "base/strings/strcat.h"
+#include "base/system/sys_info.h"
+
+namespace base::miracle_parameter {
+
+std::string GetParamNameWithSuffix(const std::string& param_name) {
+  // `base::SysInfo::AmountOfPhysicalMemoryMB()` refers to CommandLine
+  // internally. If the CommandLine is not initialized, we return early to avoid
+  // a crash.
+  if (!base::CommandLine::InitializedForCurrentProcess()) {
+    return param_name;
+  }
+  int physical_memory_mb = base::SysInfo::AmountOfPhysicalMemoryMB();
+  const char* suffix =
+      physical_memory_mb < kMiracleParameterMemory512MB  ? "ForLessThan512MB"
+      : physical_memory_mb < kMiracleParameterMemory1GB  ? "For512MBTo1GB"
+      : physical_memory_mb < kMiracleParameterMemory2GB  ? "For1GBTo2GB"
+      : physical_memory_mb < kMiracleParameterMemory4GB  ? "For2GBTo4GB"
+      : physical_memory_mb < kMiracleParameterMemory8GB  ? "For4GBTo8GB"
+      : physical_memory_mb < kMiracleParameterMemory16GB ? "For8GBTo16GB"
+                                                         : "For16GBAndAbove";
+  return base::StrCat({param_name, suffix});
+}
+
+std::string GetMiracleParameterAsString(const base::Feature& feature,
+                                        const std::string& param_name,
+                                        const std::string& default_value) {
+  return GetFieldTrialParamByFeatureAsString(
+      feature, GetParamNameWithSuffix(param_name),
+      GetFieldTrialParamByFeatureAsString(feature, param_name, default_value));
+}
+
+double GetMiracleParameterAsDouble(const base::Feature& feature,
+                                   const std::string& param_name,
+                                   double default_value) {
+  return base::GetFieldTrialParamByFeatureAsDouble(
+      feature, GetParamNameWithSuffix(param_name),
+      base::GetFieldTrialParamByFeatureAsDouble(feature, param_name,
+                                                default_value));
+}
+
+int GetMiracleParameterAsInt(const base::Feature& feature,
+                             const std::string& param_name,
+                             int default_value) {
+  return base::GetFieldTrialParamByFeatureAsInt(
+      feature, GetParamNameWithSuffix(param_name),
+      base::GetFieldTrialParamByFeatureAsInt(feature, param_name,
+                                             default_value));
+}
+
+bool GetMiracleParameterAsBool(const base::Feature& feature,
+                               const std::string& param_name,
+                               bool default_value) {
+  return base::GetFieldTrialParamByFeatureAsBool(
+      feature, GetParamNameWithSuffix(param_name),
+      base::GetFieldTrialParamByFeatureAsBool(feature, param_name,
+                                              default_value));
+}
+
+base::TimeDelta GetMiracleParameterAsTimeDelta(const base::Feature& feature,
+                                               const std::string& param_name,
+                                               base::TimeDelta default_value) {
+  return base::GetFieldTrialParamByFeatureAsTimeDelta(
+      feature, GetParamNameWithSuffix(param_name),
+      base::GetFieldTrialParamByFeatureAsTimeDelta(feature, param_name,
+                                                   default_value));
+}
+
+}  // namespace base::miracle_parameter

src/base/allocator/miracle_parameter.h

@@ -0,0 +1,177 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_ALLOCATOR_MIRACLE_PARAMETER_H_
+#define BASE_ALLOCATOR_MIRACLE_PARAMETER_H_
+
+#include "base/base_export.h"
+#include "base/containers/span.h"
+#include "base/feature_list.h"
+#include "base/metrics/field_trial_params.h"
+
+// This is a mirror copy of the //components/miracle_parameter/ to resolve the
+// dependency cycle of (base->miracle_parameter->base).
+// Eventually the miracle_parameter component will have a public interface in
+// //base/ and this could be removed.
+// TODO(crbug.com/40279826): remove miracle_parameter from
+// //base/allocator/.
+
+namespace base {
+
+namespace miracle_parameter {
+
+namespace {
+
+template <typename Enum>
+Enum GetFieldTrialParamByFeatureAsEnum(
+    const base::Feature& feature,
+    const std::string& param_name,
+    const Enum default_value,
+    const base::span<const typename base::FeatureParam<Enum>::Option>&
+        options) {
+  std::string string_value =
+      base::GetFieldTrialParamValueByFeature(feature, param_name);
+  if (string_value.empty()) {
+    return default_value;
+  }
+
+  for (const auto& option : options) {
+    if (string_value == option.name) {
+      return option.value;
+    }
+  }
+
+  base::LogInvalidEnumValue(feature, param_name, string_value,
+                            static_cast<int>(default_value));
+  return default_value;
+}
+
+}  // namespace
+
+constexpr int kMiracleParameterMemory512MB = 512;
+constexpr int kMiracleParameterMemory1GB = 1024;
+constexpr int kMiracleParameterMemory2GB = 2 * 1024;
+constexpr int kMiracleParameterMemory4GB = 4 * 1024;
+constexpr int kMiracleParameterMemory8GB = 8 * 1024;
+constexpr int kMiracleParameterMemory16GB = 16 * 1024;
+
+// GetParamNameWithSuffix put a parameter name suffix based on
+// the amount of physical memory.
+//
+// - "ForLessThan512MB" for less than 512MB memory devices.
+// - "For512MBTo1GB" for 512MB to 1GB memory devices.
+// - "For1GBTo2GB" for 1GB to 2GB memory devices.
+// - "For2GBTo4GB" for 2GB to 4GB memory devices.
+// - "For4GBTo8GB" for 4GB to 8GB memory devices.
+// - "For8GBTo16GB" for 8GB to 16GB memory devices.
+// - "For16GBAndAbove" for 16GB memory and above devices.
+BASE_EXPORT
+std::string GetParamNameWithSuffix(const std::string& param_name);
+
+// Provides a similar behavior with FeatureParam<std::string> except the return
+// value is determined by the amount of physical memory.
+BASE_EXPORT
+std::string GetMiracleParameterAsString(const base::Feature& feature,
+                                        const std::string& param_name,
+                                        const std::string& default_value);
+
+// Provides a similar behavior with FeatureParam<double> except the return value
+// is determined by the amount of physical memory.
+BASE_EXPORT
+double GetMiracleParameterAsDouble(const base::Feature& feature,
+                                   const std::string& param_name,
+                                   double default_value);
+
+// Provides a similar behavior with FeatureParam<int> except the return value is
+// determined by the amount of physical memory.
+BASE_EXPORT
+int GetMiracleParameterAsInt(const base::Feature& feature,
+                             const std::string& param_name,
+                             int default_value);
+
+// Provides a similar behavior with FeatureParam<bool> except the return value
+// is determined by the amount of physical memory.
+BASE_EXPORT
+bool GetMiracleParameterAsBool(const base::Feature& feature,
+                               const std::string& param_name,
+                               bool default_value);
+
+// Provides a similar behavior with FeatureParam<base::TimeDelta> except the
+// return value is determined by the amount of physical memory.
+BASE_EXPORT
+base::TimeDelta GetMiracleParameterAsTimeDelta(const base::Feature& feature,
+                                               const std::string& param_name,
+                                               base::TimeDelta default_value);
+
+// Provides a similar behavior with FeatureParam<Enum> except the return value
+// is determined by the amount of physical memory.
+template <typename Enum>
+Enum GetMiracleParameterAsEnum(
+    const base::Feature& feature,
+    const std::string& param_name,
+    const Enum default_value,
+    const base::span<const typename base::FeatureParam<Enum>::Option> options) {
+  return GetFieldTrialParamByFeatureAsEnum(
+      feature, GetParamNameWithSuffix(param_name),
+      GetFieldTrialParamByFeatureAsEnum(feature, param_name, default_value,
+                                        options),
+      options);
+}
+
+#define MIRACLE_PARAMETER_FOR_STRING(function_name, feature, param_name,    \
+                                     default_value)                         \
+  std::string function_name() {                                             \
+    static const std::string value =                                        \
+        miracle_parameter::GetMiracleParameterAsString(feature, param_name, \
+                                                       default_value);      \
+    return value;                                                           \
+  }
+
+#define MIRACLE_PARAMETER_FOR_DOUBLE(function_name, feature, param_name,    \
+                                     default_value)                         \
+  double function_name() {                                                  \
+    static const double value =                                             \
+        miracle_parameter::GetMiracleParameterAsDouble(feature, param_name, \
+                                                       default_value);      \
+    return value;                                                           \
+  }
+
+#define MIRACLE_PARAMETER_FOR_INT(function_name, feature, param_name,     \
+                                  default_value)                          \
+  int function_name() {                                                   \
+    static const int value = miracle_parameter::GetMiracleParameterAsInt( \
+        feature, param_name, default_value);                              \
+    return value;                                                         \
+  }
+
+#define MIRACLE_PARAMETER_FOR_BOOL(function_name, feature, param_name,      \
+                                   default_value)                           \
+  bool function_name() {                                                    \
+    static const bool value = miracle_parameter::GetMiracleParameterAsBool( \
+        feature, param_name, default_value);                                \
+    return value;                                                           \
+  }
+
+#define MIRACLE_PARAMETER_FOR_TIME_DELTA(function_name, feature, param_name,   \
+                                         default_value)                        \
+  base::TimeDelta function_name() {                                            \
+    static const base::TimeDelta value =                                       \
+        miracle_parameter::GetMiracleParameterAsTimeDelta(feature, param_name, \
+                                                          default_value);      \
+    return value;                                                              \
+  }
+
+#define MIRACLE_PARAMETER_FOR_ENUM(function_name, feature, param_name,      \
+                                   default_value, type, options)            \
+  type function_name() {                                                    \
+    static const type value = miracle_parameter::GetMiracleParameterAsEnum( \
+        feature, param_name, default_value, base::span(options));           \
+    return value;                                                           \
+  }
+
+}  // namespace miracle_parameter
+
+}  // namespace base
+
+#endif  // BASE_ALLOCATOR_MIRACLE_PARAMETER_H_

src/base/allocator/partition_alloc_features.cc

@@ -4,18 +4,41 @@
 
 #include "base/allocator/partition_alloc_features.h"
 
-#include "base/allocator/buildflags.h"
-#include "base/allocator/partition_allocator/partition_alloc_buildflags.h"
+#include "base/allocator/miracle_parameter.h"
 #include "base/base_export.h"
 #include "base/feature_list.h"
+#include "base/features.h"
+#include "base/metrics/field_trial_params.h"
+#include "base/time/time.h"
 #include "build/build_config.h"
+#include "build/chromecast_buildflags.h"
+#include "partition_alloc/buildflags.h"
+#include "partition_alloc/partition_alloc_base/time/time.h"
+#include "partition_alloc/partition_alloc_constants.h"
+#include "partition_alloc/partition_root.h"
+#include "partition_alloc/shim/allocator_shim_dispatch_to_noop_on_free.h"
+#include "partition_alloc/thread_cache.h"
 
-namespace base {
-namespace features {
+namespace base::features {
+
+namespace {
+
+static constexpr char kPAFeatureEnabledProcessesStr[] = "enabled-processes";
+static constexpr char kBrowserOnlyStr[] = "browser-only";
+static constexpr char kBrowserAndRendererStr[] = "browser-and-renderer";
+static constexpr char kNonRendererStr[] = "non-renderer";
+static constexpr char kAllProcessesStr[] = "all-processes";
+
+#if PA_CONFIG(ENABLE_SHADOW_METADATA)
+static constexpr char kRendererOnlyStr[] = "renderer-only";
+static constexpr char kAllChildProcessesStr[] = "all-child-processes";
+#endif  // PA_CONFIG(ENABLE_SHADOW_METADATA)
+
+}  // namespace
 
 BASE_FEATURE(kPartitionAllocUnretainedDanglingPtr,
              "PartitionAllocUnretainedDanglingPtr",
-             FEATURE_DISABLED_BY_DEFAULT);
+             FEATURE_ENABLED_BY_DEFAULT);
 
 constexpr FeatureParam<UnretainedDanglingPtrMode>::Option
     kUnretainedDanglingPtrModeOption[] = {
@@ -23,74 +46,128 @@ constexpr FeatureParam<UnretainedDanglingPtrMode>::Option
         {UnretainedDanglingPtrMode::kDumpWithoutCrashing,
          "dump_without_crashing"},
 };
-const base::FeatureParam<UnretainedDanglingPtrMode>
+// Note: Do not use the prepared macro as of no need for a local cache.
+constinit const FeatureParam<UnretainedDanglingPtrMode>
     kUnretainedDanglingPtrModeParam = {
         &kPartitionAllocUnretainedDanglingPtr,
         "mode",
-        UnretainedDanglingPtrMode::kDumpWithoutCrashing,
+        UnretainedDanglingPtrMode::kCrash,
         &kUnretainedDanglingPtrModeOption,
 };
 
+// Note: DPD conflicts with no-op `free()` (see
+// `base::allocator::MakeFreeNoOp()`). No-op `free()` stands down in the
+// presence of DPD, but hypothetically fully launching DPD should prompt
+// a rethink of no-op `free()`.
 BASE_FEATURE(kPartitionAllocDanglingPtr,
              "PartitionAllocDanglingPtr",
-             FEATURE_DISABLED_BY_DEFAULT);
+#if PA_BUILDFLAG(ENABLE_DANGLING_RAW_PTR_FEATURE_FLAG)
+             FEATURE_ENABLED_BY_DEFAULT
+#else
+             FEATURE_DISABLED_BY_DEFAULT
+#endif
+);
+
 constexpr FeatureParam<DanglingPtrMode>::Option kDanglingPtrModeOption[] = {
     {DanglingPtrMode::kCrash, "crash"},
-    {DanglingPtrMode::kLogSignature, "log_signature"},
+    {DanglingPtrMode::kLogOnly, "log_only"},
 };
-const base::FeatureParam<DanglingPtrMode> kDanglingPtrModeParam{
+// Note: Do not use the prepared macro as of no need for a local cache.
+constinit const FeatureParam<DanglingPtrMode> kDanglingPtrModeParam{
     &kPartitionAllocDanglingPtr,
     "mode",
     DanglingPtrMode::kCrash,
     &kDanglingPtrModeOption,
 };
+constexpr FeatureParam<DanglingPtrType>::Option kDanglingPtrTypeOption[] = {
+    {DanglingPtrType::kAll, "all"},
+    {DanglingPtrType::kCrossTask, "cross_task"},
+};
+// Note: Do not use the prepared macro as of no need for a local cache.
+constinit const FeatureParam<DanglingPtrType> kDanglingPtrTypeParam{
+    &kPartitionAllocDanglingPtr,
+    "type",
+    DanglingPtrType::kAll,
+    &kDanglingPtrTypeOption,
+};
 
-#if defined(PA_ALLOW_PCSCAN)
-// If enabled, PCScan is turned on by default for all partitions that don't
-// disable it explicitly.
-BASE_FEATURE(kPartitionAllocPCScan,
-             "PartitionAllocPCScan",
-             FEATURE_DISABLED_BY_DEFAULT);
-#endif  // defined(PA_ALLOW_PCSCAN)
-
-#if BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
-// If enabled, PCScan is turned on only for the browser's malloc partition.
-BASE_FEATURE(kPartitionAllocPCScanBrowserOnly,
-             "PartitionAllocPCScanBrowserOnly",
-             FEATURE_DISABLED_BY_DEFAULT);
-
-// If enabled, PCScan is turned on only for the renderer's malloc partition.
-BASE_FEATURE(kPartitionAllocPCScanRendererOnly,
-             "PartitionAllocPCScanRendererOnly",
-             FEATURE_DISABLED_BY_DEFAULT);
-
-// If enabled, this instance belongs to the Control group of the BackupRefPtr
-// binary experiment.
-BASE_FEATURE(kPartitionAllocBackupRefPtrControl,
-             "PartitionAllocBackupRefPtrControl",
-             FEATURE_DISABLED_BY_DEFAULT);
-
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
 // Use a larger maximum thread cache cacheable bucket size.
 BASE_FEATURE(kPartitionAllocLargeThreadCacheSize,
              "PartitionAllocLargeThreadCacheSize",
-#if BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS)
-             // Not unconditionally enabled on 32 bit Android, since it is a
-             // more memory-constrained platform.
-             FEATURE_DISABLED_BY_DEFAULT
-#else
-             FEATURE_ENABLED_BY_DEFAULT
-#endif
-);
+             FEATURE_ENABLED_BY_DEFAULT);
+
+MIRACLE_PARAMETER_FOR_INT(GetPartitionAllocLargeThreadCacheSizeValue,
+                          kPartitionAllocLargeThreadCacheSize,
+                          "PartitionAllocLargeThreadCacheSizeValue",
+                          ::partition_alloc::kThreadCacheLargeSizeThreshold)
+
+MIRACLE_PARAMETER_FOR_INT(
+    GetPartitionAllocLargeThreadCacheSizeValueForLowRAMAndroid,
+    kPartitionAllocLargeThreadCacheSize,
+    "PartitionAllocLargeThreadCacheSizeValueForLowRAMAndroid",
+    ::partition_alloc::kThreadCacheDefaultSizeThreshold)
 
 BASE_FEATURE(kPartitionAllocLargeEmptySlotSpanRing,
              "PartitionAllocLargeEmptySlotSpanRing",
+#if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_WIN)
+             FEATURE_ENABLED_BY_DEFAULT);
+#else
              FEATURE_DISABLED_BY_DEFAULT);
-#endif  // BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
+#endif
+
+BASE_FEATURE(kPartitionAllocWithAdvancedChecks,
+             "PartitionAllocWithAdvancedChecks",
+             FEATURE_DISABLED_BY_DEFAULT);
+constexpr FeatureParam<PartitionAllocWithAdvancedChecksEnabledProcesses>::Option
+    kPartitionAllocWithAdvancedChecksEnabledProcessesOptions[] = {
+        {PartitionAllocWithAdvancedChecksEnabledProcesses::kBrowserOnly,
+         kBrowserOnlyStr},
+        {PartitionAllocWithAdvancedChecksEnabledProcesses::kBrowserAndRenderer,
+         kBrowserAndRendererStr},
+        {PartitionAllocWithAdvancedChecksEnabledProcesses::kNonRenderer,
+         kNonRendererStr},
+        {PartitionAllocWithAdvancedChecksEnabledProcesses::kAllProcesses,
+         kAllProcessesStr}};
+// Note: Do not use the prepared macro as of no need for a local cache.
+constinit const FeatureParam<PartitionAllocWithAdvancedChecksEnabledProcesses>
+    kPartitionAllocWithAdvancedChecksEnabledProcessesParam{
+        &kPartitionAllocWithAdvancedChecks, kPAFeatureEnabledProcessesStr,
+        PartitionAllocWithAdvancedChecksEnabledProcesses::kBrowserOnly,
+        &kPartitionAllocWithAdvancedChecksEnabledProcessesOptions};
+
+BASE_FEATURE(kPartitionAllocSchedulerLoopQuarantine,
+             "PartitionAllocSchedulerLoopQuarantine",
+             FEATURE_DISABLED_BY_DEFAULT);
+// Scheduler Loop Quarantine's per-branch capacity in bytes.
+// Note: Do not use the prepared macro as of no need for a local cache.
+constinit const FeatureParam<int>
+    kPartitionAllocSchedulerLoopQuarantineBranchCapacity{
+        &kPartitionAllocSchedulerLoopQuarantine,
+        "PartitionAllocSchedulerLoopQuarantineBranchCapacity", 0};
+// Scheduler Loop Quarantine's capacity for the UI thread in bytes.
+BASE_FEATURE_PARAM(int,
+                   kPartitionAllocSchedulerLoopQuarantineBrowserUICapacity,
+                   &kPartitionAllocSchedulerLoopQuarantine,
+                   "PartitionAllocSchedulerLoopQuarantineBrowserUICapacity",
+                   0);
+
+BASE_FEATURE(kPartitionAllocZappingByFreeFlags,
+             "PartitionAllocZappingByFreeFlags",
+             FEATURE_DISABLED_BY_DEFAULT);
+
+BASE_FEATURE(kPartitionAllocEventuallyZeroFreedMemory,
+             "PartitionAllocEventuallyZeroFreedMemory",
+             FEATURE_DISABLED_BY_DEFAULT);
+
+BASE_FEATURE(kPartitionAllocFewerMemoryRegions,
+             "PartitionAllocFewerMemoryRegions",
+             FEATURE_DISABLED_BY_DEFAULT);
+#endif  // PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
 
 BASE_FEATURE(kPartitionAllocBackupRefPtr,
              "PartitionAllocBackupRefPtr",
-#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_WIN) || \
-    (BUILDFLAG(USE_ASAN_BACKUP_REF_PTR) && BUILDFLAG(IS_LINUX))
+#if PA_BUILDFLAG(ENABLE_BACKUP_REF_PTR_FEATURE_FLAG)
              FEATURE_ENABLED_BY_DEFAULT
 #else
              FEATURE_DISABLED_BY_DEFAULT
@@ -99,96 +176,186 @@ BASE_FEATURE(kPartitionAllocBackupRefPtr,
 
 constexpr FeatureParam<BackupRefPtrEnabledProcesses>::Option
     kBackupRefPtrEnabledProcessesOptions[] = {
-        {BackupRefPtrEnabledProcesses::kBrowserOnly, "browser-only"},
+        {BackupRefPtrEnabledProcesses::kBrowserOnly, kBrowserOnlyStr},
         {BackupRefPtrEnabledProcesses::kBrowserAndRenderer,
-         "browser-and-renderer"},
-        {BackupRefPtrEnabledProcesses::kNonRenderer, "non-renderer"},
-        {BackupRefPtrEnabledProcesses::kAllProcesses, "all-processes"}};
+         kBrowserAndRendererStr},
+        {BackupRefPtrEnabledProcesses::kNonRenderer, kNonRendererStr},
+        {BackupRefPtrEnabledProcesses::kAllProcesses, kAllProcessesStr}};
 
-const base::FeatureParam<BackupRefPtrEnabledProcesses>
-    kBackupRefPtrEnabledProcessesParam{
-  &kPartitionAllocBackupRefPtr, "enabled-processes",
-#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_WIN) || \
-    (BUILDFLAG(USE_ASAN_BACKUP_REF_PTR) && BUILDFLAG(IS_LINUX))
-      BackupRefPtrEnabledProcesses::kNonRenderer,
+BASE_FEATURE_ENUM_PARAM(BackupRefPtrEnabledProcesses,
+                        kBackupRefPtrEnabledProcessesParam,
+                        &kPartitionAllocBackupRefPtr,
+                        kPAFeatureEnabledProcessesStr,
+#if PA_BUILDFLAG(IS_MAC) && PA_BUILDFLAG(PA_ARCH_CPU_ARM64)
+                        BackupRefPtrEnabledProcesses::kNonRenderer,
 #else
-      BackupRefPtrEnabledProcesses::kBrowserOnly,
+                        BackupRefPtrEnabledProcesses::kAllProcesses,
 #endif
-      &kBackupRefPtrEnabledProcessesOptions
-};
+                        &kBackupRefPtrEnabledProcessesOptions);
 
 constexpr FeatureParam<BackupRefPtrMode>::Option kBackupRefPtrModeOptions[] = {
     {BackupRefPtrMode::kDisabled, "disabled"},
     {BackupRefPtrMode::kEnabled, "enabled"},
-    {BackupRefPtrMode::kEnabledWithoutZapping, "enabled-without-zapping"},
-    {BackupRefPtrMode::kDisabledButSplitPartitions2Way,
-     "disabled-but-2-way-split"},
-    {BackupRefPtrMode::kDisabledButSplitPartitions3Way,
-     "disabled-but-3-way-split"},
-    {BackupRefPtrMode::kDisabledButAddDummyRefCount,
-     "disabled-but-add-dummy-ref-count"},
 };
 
-const base::FeatureParam<BackupRefPtrMode> kBackupRefPtrModeParam{
-    &kPartitionAllocBackupRefPtr, "brp-mode", BackupRefPtrMode::kEnabled,
-    &kBackupRefPtrModeOptions};
+BASE_FEATURE_ENUM_PARAM(BackupRefPtrMode,
+                        kBackupRefPtrModeParam,
+                        &kPartitionAllocBackupRefPtr,
+                        "brp-mode",
+                        BackupRefPtrMode::kEnabled,
+                        &kBackupRefPtrModeOptions);
+// Note: Do not use the prepared macro as of no need for a local cache.
+constinit const FeatureParam<int> kBackupRefPtrExtraExtrasSizeParam{
+    &kPartitionAllocBackupRefPtr, "brp-extra-extras-size", 0};
 
-const base::FeatureParam<bool> kBackupRefPtrAsanEnableDereferenceCheckParam{
-    &kPartitionAllocBackupRefPtr, "asan-enable-dereference-check", true};
-const base::FeatureParam<bool> kBackupRefPtrAsanEnableExtractionCheckParam{
-    &kPartitionAllocBackupRefPtr, "asan-enable-extraction-check",
-    false};  // Not much noise at the moment to enable by default.
-const base::FeatureParam<bool> kBackupRefPtrAsanEnableInstantiationCheckParam{
-    &kPartitionAllocBackupRefPtr, "asan-enable-instantiation-check", true};
-
-// If enabled, switches the bucket distribution to an alternate one. Only one of
-// these features may b e enabled at a time.
-BASE_FEATURE(kPartitionAllocUseAlternateDistribution,
-             "PartitionAllocUseAlternateDistribution",
-             FEATURE_DISABLED_BY_DEFAULT);
-const base::FeatureParam<AlternateBucketDistributionMode>::Option
-    kPartitionAllocAlternateDistributionOption[] = {
-        {AlternateBucketDistributionMode::kDefault, "default"},
-        {AlternateBucketDistributionMode::kCoarser, "coarser"},
-        {AlternateBucketDistributionMode::kDenser, "denser"},
-};
-const base::FeatureParam<AlternateBucketDistributionMode>
-    kPartitionAllocAlternateBucketDistributionParam{
-        &kPartitionAllocUseAlternateDistribution, "mode",
-        AlternateBucketDistributionMode::kDefault,
-        &kPartitionAllocAlternateDistributionOption};
-
-// If enabled, switches PCScan scheduling to a mutator-aware scheduler. Does not
-// affect whether PCScan is enabled itself.
-BASE_FEATURE(kPartitionAllocPCScanMUAwareScheduler,
-             "PartitionAllocPCScanMUAwareScheduler",
-             FEATURE_ENABLED_BY_DEFAULT);
-
-// If enabled, PCScan frees unconditionally all quarantined objects.
-// This is a performance testing feature.
-BASE_FEATURE(kPartitionAllocPCScanImmediateFreeing,
-             "PartitionAllocPCScanImmediateFreeing",
-             FEATURE_DISABLED_BY_DEFAULT);
-
-// If enabled, PCScan clears eagerly (synchronously) on free().
-BASE_FEATURE(kPartitionAllocPCScanEagerClearing,
-             "PartitionAllocPCScanEagerClearing",
-             FEATURE_DISABLED_BY_DEFAULT);
-
-// In addition to heap, scan also the stack of the current mutator.
-BASE_FEATURE(kPartitionAllocPCScanStackScanning,
-             "PartitionAllocPCScanStackScanning",
-#if defined(PA_PCSCAN_STACK_SUPPORTED)
+BASE_FEATURE(kPartitionAllocMemoryTagging,
+             "PartitionAllocMemoryTagging",
+#if PA_BUILDFLAG(USE_FULL_MTE) || BUILDFLAG(IS_ANDROID)
              FEATURE_ENABLED_BY_DEFAULT
 #else
              FEATURE_DISABLED_BY_DEFAULT
-#endif  // defined(PA_PCSCAN_STACK_SUPPORTED)
+#endif
 );
 
-BASE_FEATURE(kPartitionAllocDCScan,
-             "PartitionAllocDCScan",
+constexpr FeatureParam<MemtagMode>::Option kMemtagModeOptions[] = {
+    {MemtagMode::kSync, "sync"},
+    {MemtagMode::kAsync, "async"}};
+
+// Note: Do not use the prepared macro as of no need for a local cache.
+constinit const FeatureParam<MemtagMode> kMemtagModeParam{
+    &kPartitionAllocMemoryTagging, "memtag-mode",
+#if PA_BUILDFLAG(USE_FULL_MTE)
+    MemtagMode::kSync,
+#else
+    MemtagMode::kAsync,
+#endif
+    &kMemtagModeOptions};
+
+constexpr FeatureParam<RetagMode>::Option kRetagModeOptions[] = {
+    {RetagMode::kIncrement, "increment"},
+    {RetagMode::kRandom, "random"},
+};
+
+// Note: Do not use the prepared macro as of no need for a local cache.
+constinit const FeatureParam<RetagMode> kRetagModeParam{
+    &kPartitionAllocMemoryTagging, "retag-mode", RetagMode::kIncrement,
+    &kRetagModeOptions};
+
+constexpr FeatureParam<MemoryTaggingEnabledProcesses>::Option
+    kMemoryTaggingEnabledProcessesOptions[] = {
+        {MemoryTaggingEnabledProcesses::kBrowserOnly, kBrowserOnlyStr},
+        {MemoryTaggingEnabledProcesses::kNonRenderer, kNonRendererStr},
+        {MemoryTaggingEnabledProcesses::kAllProcesses, kAllProcessesStr}};
+
+// Note: Do not use the prepared macro as of no need for a local cache.
+constinit const FeatureParam<MemoryTaggingEnabledProcesses>
+    kMemoryTaggingEnabledProcessesParam{
+        &kPartitionAllocMemoryTagging, kPAFeatureEnabledProcessesStr,
+#if PA_BUILDFLAG(USE_FULL_MTE)
+        MemoryTaggingEnabledProcesses::kAllProcesses,
+#else
+        MemoryTaggingEnabledProcesses::kNonRenderer,
+#endif
+        &kMemoryTaggingEnabledProcessesOptions};
+
+BASE_FEATURE(kKillPartitionAllocMemoryTagging,
+             "KillPartitionAllocMemoryTagging",
              FEATURE_DISABLED_BY_DEFAULT);
 
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocPermissiveMte);
+BASE_FEATURE(kPartitionAllocPermissiveMte,
+             "PartitionAllocPermissiveMte",
+#if PA_BUILDFLAG(USE_FULL_MTE)
+             // We want to actually crash if USE_FULL_MTE is enabled.
+             FEATURE_DISABLED_BY_DEFAULT
+#else
+             FEATURE_ENABLED_BY_DEFAULT
+#endif
+);
+
+BASE_FEATURE(kAsanBrpDereferenceCheck,
+             "AsanBrpDereferenceCheck",
+             FEATURE_ENABLED_BY_DEFAULT);
+BASE_FEATURE(kAsanBrpExtractionCheck,
+             "AsanBrpExtractionCheck",      // Not much noise at the moment to
+             FEATURE_DISABLED_BY_DEFAULT);  // enable by default.
+BASE_FEATURE(kAsanBrpInstantiationCheck,
+             "AsanBrpInstantiationCheck",
+             FEATURE_ENABLED_BY_DEFAULT);
+
+// If enabled, switches the bucket distribution to a denser one.
+//
+// We enable this by default everywhere except for 32-bit Android, since we saw
+// regressions there.
+BASE_FEATURE(kPartitionAllocUseDenserDistribution,
+             "PartitionAllocUseDenserDistribution",
+#if BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS)
+             FEATURE_DISABLED_BY_DEFAULT
+#else
+             FEATURE_ENABLED_BY_DEFAULT
+#endif  // BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS)
+);
+const FeatureParam<BucketDistributionMode>::Option
+    kPartitionAllocBucketDistributionOption[] = {
+        {BucketDistributionMode::kDefault, "default"},
+        {BucketDistributionMode::kDenser, "denser"},
+};
+// Note: Do not use the prepared macro as of no need for a local cache.
+constinit const FeatureParam<BucketDistributionMode>
+    kPartitionAllocBucketDistributionParam{
+        &kPartitionAllocUseDenserDistribution, "mode",
+#if BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS)
+        BucketDistributionMode::kDefault,
+#else
+        BucketDistributionMode::kDenser,
+#endif  // BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS)
+        &kPartitionAllocBucketDistributionOption};
+
+BASE_FEATURE(kPartitionAllocMemoryReclaimer,
+             "PartitionAllocMemoryReclaimer",
+             FEATURE_ENABLED_BY_DEFAULT);
+BASE_FEATURE_PARAM(TimeDelta,
+                   kPartitionAllocMemoryReclaimerInterval,
+                   &kPartitionAllocMemoryReclaimer,
+                   "interval",
+                   TimeDelta()  // Defaults to zero.
+);
+
+// Configures whether we set a lower limit for renderers that do not have a main
+// frame, similar to the limit that is already done for backgrounded renderers.
+BASE_FEATURE(kLowerPAMemoryLimitForNonMainRenderers,
+             "LowerPAMemoryLimitForNonMainRenderers",
+             FEATURE_DISABLED_BY_DEFAULT);
+
+// Whether to straighten free lists for larger slot spans in PurgeMemory() ->
+// ... -> PartitionPurgeSlotSpan().
+BASE_FEATURE(kPartitionAllocStraightenLargerSlotSpanFreeLists,
+             "PartitionAllocStraightenLargerSlotSpanFreeLists",
+             FEATURE_ENABLED_BY_DEFAULT);
+const FeatureParam<partition_alloc::StraightenLargerSlotSpanFreeListsMode>::
+    Option kPartitionAllocStraightenLargerSlotSpanFreeListsModeOption[] = {
+        {partition_alloc::StraightenLargerSlotSpanFreeListsMode::
+             kOnlyWhenUnprovisioning,
+         "only-when-unprovisioning"},
+        {partition_alloc::StraightenLargerSlotSpanFreeListsMode::kAlways,
+         "always"},
+};
+// Note: Do not use the prepared macro as of no need for a local cache.
+constinit const FeatureParam<
+    partition_alloc::StraightenLargerSlotSpanFreeListsMode>
+    kPartitionAllocStraightenLargerSlotSpanFreeListsMode = {
+        &kPartitionAllocStraightenLargerSlotSpanFreeLists,
+        "mode",
+        partition_alloc::StraightenLargerSlotSpanFreeListsMode::
+            kOnlyWhenUnprovisioning,
+        &kPartitionAllocStraightenLargerSlotSpanFreeListsModeOption,
+};
+
+// Whether to sort free lists for smaller slot spans in PurgeMemory().
+BASE_FEATURE(kPartitionAllocSortSmallerSlotSpanFreeLists,
+             "PartitionAllocSortSmallerSlotSpanFreeLists",
+             FEATURE_ENABLED_BY_DEFAULT);
+
 // Whether to sort the active slot spans in PurgeMemory().
 BASE_FEATURE(kPartitionAllocSortActiveSlotSpans,
              "PartitionAllocSortActiveSlotSpans",
@@ -201,5 +368,133 @@ BASE_FEATURE(kPageAllocatorRetryOnCommitFailure,
              FEATURE_DISABLED_BY_DEFAULT);
 #endif
 
-}  // namespace features
-}  // namespace base
+#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_CHROMEOS)
+// A parameter to exclude or not exclude PartitionAllocSupport from
+// PartialLowModeOnMidRangeDevices. This is used to see how it affects
+// renderer performances, e.g. blink_perf.parser benchmark.
+// The feature: kPartialLowEndModeOnMidRangeDevices is defined in
+// //base/features.cc. Since the following feature param is related to
+// PartitionAlloc, define the param here.
+BASE_FEATURE_PARAM(bool,
+                   kPartialLowEndModeExcludePartitionAllocSupport,
+                   &kPartialLowEndModeOnMidRangeDevices,
+                   "exclude-partition-alloc-support",
+                   false);
+#endif
+
+BASE_FEATURE(kEnableConfigurableThreadCacheMultiplier,
+             "EnableConfigurableThreadCacheMultiplier",
+             base::FEATURE_DISABLED_BY_DEFAULT);
+
+MIRACLE_PARAMETER_FOR_DOUBLE(GetThreadCacheMultiplier,
+                             kEnableConfigurableThreadCacheMultiplier,
+                             "ThreadCacheMultiplier",
+                             2.)
+
+MIRACLE_PARAMETER_FOR_DOUBLE(GetThreadCacheMultiplierForAndroid,
+                             kEnableConfigurableThreadCacheMultiplier,
+                             "ThreadCacheMultiplierForAndroid",
+                             1.)
+
+constexpr partition_alloc::internal::base::TimeDelta ToPartitionAllocTimeDelta(
+    TimeDelta time_delta) {
+  return partition_alloc::internal::base::Microseconds(
+      time_delta.InMicroseconds());
+}
+
+constexpr TimeDelta FromPartitionAllocTimeDelta(
+    partition_alloc::internal::base::TimeDelta time_delta) {
+  return Microseconds(time_delta.InMicroseconds());
+}
+
+BASE_FEATURE(kEnableConfigurableThreadCachePurgeInterval,
+             "EnableConfigurableThreadCachePurgeInterval",
+             FEATURE_DISABLED_BY_DEFAULT);
+
+MIRACLE_PARAMETER_FOR_TIME_DELTA(
+    GetThreadCacheMinPurgeIntervalValue,
+    kEnableConfigurableThreadCachePurgeInterval,
+    "ThreadCacheMinPurgeInterval",
+    FromPartitionAllocTimeDelta(partition_alloc::kMinPurgeInterval))
+
+MIRACLE_PARAMETER_FOR_TIME_DELTA(
+    GetThreadCacheMaxPurgeIntervalValue,
+    kEnableConfigurableThreadCachePurgeInterval,
+    "ThreadCacheMaxPurgeInterval",
+    FromPartitionAllocTimeDelta(partition_alloc::kMaxPurgeInterval))
+
+MIRACLE_PARAMETER_FOR_TIME_DELTA(
+    GetThreadCacheDefaultPurgeIntervalValue,
+    kEnableConfigurableThreadCachePurgeInterval,
+    "ThreadCacheDefaultPurgeInterval",
+    FromPartitionAllocTimeDelta(partition_alloc::kDefaultPurgeInterval))
+
+const partition_alloc::internal::base::TimeDelta
+GetThreadCacheMinPurgeInterval() {
+  return ToPartitionAllocTimeDelta(GetThreadCacheMinPurgeIntervalValue());
+}
+
+const partition_alloc::internal::base::TimeDelta
+GetThreadCacheMaxPurgeInterval() {
+  return ToPartitionAllocTimeDelta(GetThreadCacheMaxPurgeIntervalValue());
+}
+
+const partition_alloc::internal::base::TimeDelta
+GetThreadCacheDefaultPurgeInterval() {
+  return ToPartitionAllocTimeDelta(GetThreadCacheDefaultPurgeIntervalValue());
+}
+
+BASE_FEATURE(kEnableConfigurableThreadCacheMinCachedMemoryForPurging,
+             "EnableConfigurableThreadCacheMinCachedMemoryForPurging",
+             FEATURE_DISABLED_BY_DEFAULT);
+
+MIRACLE_PARAMETER_FOR_INT(
+    GetThreadCacheMinCachedMemoryForPurgingBytes,
+    kEnableConfigurableThreadCacheMinCachedMemoryForPurging,
+    "ThreadCacheMinCachedMemoryForPurgingBytes",
+    partition_alloc::kMinCachedMemoryForPurgingBytes)
+
+// An apparent quarantine leak in the buffer partition unacceptably
+// bloats memory when MiraclePtr is enabled in the renderer process.
+// We believe we have found and patched the leak, but out of an
+// abundance of caution, we provide this toggle that allows us to
+// wholly disable MiraclePtr in the buffer partition, if necessary.
+//
+// TODO(crbug.com/40064499): this is unneeded once
+// MiraclePtr-for-Renderer launches.
+BASE_FEATURE(kPartitionAllocDisableBRPInBufferPartition,
+             "PartitionAllocDisableBRPInBufferPartition",
+             FEATURE_DISABLED_BY_DEFAULT);
+
+BASE_FEATURE(kPartitionAllocAdjustSizeWhenInForeground,
+             "PartitionAllocAdjustSizeWhenInForeground",
+#if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_WIN)
+             FEATURE_ENABLED_BY_DEFAULT);
+#else
+             FEATURE_DISABLED_BY_DEFAULT);
+#endif
+
+BASE_FEATURE(kPartitionAllocUseSmallSingleSlotSpans,
+             "PartitionAllocUseSmallSingleSlotSpans",
+             FEATURE_ENABLED_BY_DEFAULT);
+
+#if PA_CONFIG(ENABLE_SHADOW_METADATA)
+BASE_FEATURE(kPartitionAllocShadowMetadata,
+             "PartitionAllocShadowMetadata",
+             FEATURE_DISABLED_BY_DEFAULT);
+
+constexpr FeatureParam<ShadowMetadataEnabledProcesses>::Option
+    kShadowMetadataEnabledProcessesOptions[] = {
+        {ShadowMetadataEnabledProcesses::kRendererOnly, kRendererOnlyStr},
+        {ShadowMetadataEnabledProcesses::kAllChildProcesses,
+         kAllChildProcessesStr}};
+
+// Note: Do not use the prepared macro as of no need for a local cache.
+constinit const FeatureParam<ShadowMetadataEnabledProcesses>
+    kShadowMetadataEnabledProcessesParam{
+        &kPartitionAllocShadowMetadata, kPAFeatureEnabledProcessesStr,
+        ShadowMetadataEnabledProcesses::kRendererOnly,
+        &kShadowMetadataEnabledProcessesOptions};
+#endif  // PA_CONFIG(ENABLE_SHADOW_METADATA)
+
+}  // namespace base::features

src/base/allocator/partition_alloc_features.h

@@ -5,30 +5,46 @@
 #ifndef BASE_ALLOCATOR_PARTITION_ALLOC_FEATURES_H_
 #define BASE_ALLOCATOR_PARTITION_ALLOC_FEATURES_H_
 
-#include "base/allocator/buildflags.h"
-#include "base/allocator/partition_allocator/partition_alloc_config.h"
 #include "base/base_export.h"
 #include "base/compiler_specific.h"
 #include "base/feature_list.h"
 #include "base/metrics/field_trial_params.h"
+#include "base/time/time.h"
 #include "build/build_config.h"
+#include "partition_alloc/buildflags.h"
+#include "partition_alloc/partition_alloc_base/time/time.h"
+#include "partition_alloc/partition_root.h"
 
-namespace base {
-namespace features {
+namespace base::features {
 
-extern const BASE_EXPORT Feature kPartitionAllocUnretainedDanglingPtr;
+namespace internal {
+
+enum class PAFeatureEnabledProcesses {
+  // Enabled only in the browser process.
+  kBrowserOnly,
+  // Enabled only in the browser and renderer processes.
+  kBrowserAndRenderer,
+  // Enabled in all processes, except renderer.
+  kNonRenderer,
+  // Enabled only in renderer processes.
+  kRendererOnly,
+  // Enabled in all child processes, except zygote.
+  kAllChildProcesses,
+  // Enabled in all processes.
+  kAllProcesses,
+};
+
+}  // namespace internal
+
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocUnretainedDanglingPtr);
 enum class UnretainedDanglingPtrMode {
   kCrash,
   kDumpWithoutCrashing,
 };
-extern const BASE_EXPORT base::FeatureParam<UnretainedDanglingPtrMode>
-    kUnretainedDanglingPtrModeParam;
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(UnretainedDanglingPtrMode,
+                                       kUnretainedDanglingPtrModeParam);
 
 // See /docs/dangling_ptr.md
-//
-// Usage:
-// --enable-features=PartitionAllocDanglingPtr:mode/crash
-// --enable-features=PartitionAllocDanglingPtr:mode/log_signature
 BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocDanglingPtr);
 enum class DanglingPtrMode {
   // Crash immediately after detecting a dangling raw_ptr.
@@ -36,37 +52,67 @@ enum class DanglingPtrMode {
 
   // Log the signature of every occurrences without crashing. It is used by
   // bots.
-  // Format "[DanglingSignature]\t<1>\t<2>"
-  // 1. The function who freed the memory while it was still referenced.
-  // 2. The function who released the raw_ptr reference.
-  kLogSignature,
+  // Format "[DanglingSignature]\t<1>\t<2>\t<3>\t<4>"
+  // 1. The function which freed the memory while it was still referenced.
+  // 2. The task in which the memory was freed.
+  // 3. The function which released the raw_ptr reference.
+  // 4. The task in which the raw_ptr was released.
+  kLogOnly,
 
   // Note: This will be extended with a single shot DumpWithoutCrashing.
 };
-extern const BASE_EXPORT base::FeatureParam<DanglingPtrMode>
-    kDanglingPtrModeParam;
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(DanglingPtrMode, kDanglingPtrModeParam);
+enum class DanglingPtrType {
+  // Act on any dangling raw_ptr released after being freed.
+  kAll,  // (default)
 
-#if defined(PA_ALLOW_PCSCAN)
-BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocPCScan);
-#endif  // defined(PA_ALLOW_PCSCAN)
-#if BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
-BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocPCScanBrowserOnly);
-BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocPCScanRendererOnly);
-BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocBackupRefPtrControl);
-BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocLargeThreadCacheSize);
-BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocLargeEmptySlotSpanRing);
-#endif  // BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
+  // Detect when freeing memory and releasing the dangling raw_ptr happens in
+  // a different task. Those are more likely to cause use after free.
+  kCrossTask,
 
-enum class BackupRefPtrEnabledProcesses {
-  // BRP enabled only in the browser process.
-  kBrowserOnly,
-  // BRP enabled only in the browser and renderer processes.
-  kBrowserAndRenderer,
-  // BRP enabled in all processes, except renderer.
-  kNonRenderer,
-  // BRP enabled in all processes.
-  kAllProcesses,
+  // Note: This will be extended with LongLived
 };
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(DanglingPtrType, kDanglingPtrTypeParam);
+
+using PartitionAllocWithAdvancedChecksEnabledProcesses =
+    internal::PAFeatureEnabledProcesses;
+
+#if PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocLargeThreadCacheSize);
+BASE_EXPORT int GetPartitionAllocLargeThreadCacheSizeValue();
+BASE_EXPORT int GetPartitionAllocLargeThreadCacheSizeValueForLowRAMAndroid();
+
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocLargeEmptySlotSpanRing);
+
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocWithAdvancedChecks);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(
+    PartitionAllocWithAdvancedChecksEnabledProcesses,
+    kPartitionAllocWithAdvancedChecksEnabledProcessesParam);
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocSchedulerLoopQuarantine);
+// Scheduler Loop Quarantine's per-thread capacity in bytes.
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(
+    int,
+    kPartitionAllocSchedulerLoopQuarantineBranchCapacity);
+// Scheduler Loop Quarantine's capacity for the UI thread in bytes.
+// TODO(https://crbug.com/387470567): Support more thread types.
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(
+    int,
+    kPartitionAllocSchedulerLoopQuarantineBrowserUICapacity);
+
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocZappingByFreeFlags);
+
+// Eventually zero out most PartitionAlloc memory. This is not meant as a
+// security guarantee, but to increase the compression ratio of PartitionAlloc's
+// fragmented super pages.
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocEventuallyZeroFreedMemory);
+
+// Whether to make PartitionAlloc use fewer memory regions. This matters on
+// Linux-based systems, where there is a per-process limit that we hit in some
+// cases. See the comment in PartitionBucket::SlotSpanCOmmitedSize() for detail.
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocFewerMemoryRegions);
+#endif  // PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
+
+using BackupRefPtrEnabledProcesses = internal::PAFeatureEnabledProcesses;
 
 enum class BackupRefPtrMode {
   // BRP is disabled across all partitions. Equivalent to the Finch flag being
@@ -75,58 +121,113 @@ enum class BackupRefPtrMode {
 
   // BRP is enabled in the main partition, as well as certain Renderer-only
   // partitions (if enabled in Renderer at all).
-  // This entails splitting the main partition.
   kEnabled,
-
-  // Same as kEnabled but without zapping quarantined objects.
-  kEnabledWithoutZapping,
-
-  // BRP is disabled, but the main partition is split out, as if BRP was enabled
-  // in the "previous slot" mode.
-  kDisabledButSplitPartitions2Way,
-
-  // BRP is disabled, but the main partition *and* aligned partition are split
-  // out, as if BRP was enabled in the "before allocation" mode.
-  kDisabledButSplitPartitions3Way,
-
-  //  BRP is disabled, but add dummy ref count to each allocation. This will
-  // increase allocation size but not change any of the logic. If an issue
-  // reproduce in this mode, it means the increase in size is causing it.
-  kDisabledButAddDummyRefCount,
 };
 
-enum class AlternateBucketDistributionMode : uint8_t {
+enum class MemtagMode {
+  // memtagMode will be SYNC.
+  kSync,
+  // memtagMode will be ASYNC.
+  kAsync,
+};
+
+enum class RetagMode {
+  // Allocations are retagged by incrementing the current tag.
+  kIncrement,
+
+  // Allocations are retagged with a random tag.
+  kRandom,
+};
+
+using MemoryTaggingEnabledProcesses = internal::PAFeatureEnabledProcesses;
+
+enum class BucketDistributionMode : uint8_t {
   kDefault,
-  kCoarser,
   kDenser,
 };
 
 BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocBackupRefPtr);
-extern const BASE_EXPORT base::FeatureParam<BackupRefPtrEnabledProcesses>
-    kBackupRefPtrEnabledProcessesParam;
-extern const BASE_EXPORT base::FeatureParam<BackupRefPtrMode>
-    kBackupRefPtrModeParam;
-extern const BASE_EXPORT base::FeatureParam<bool>
-    kBackupRefPtrAsanEnableDereferenceCheckParam;
-extern const BASE_EXPORT base::FeatureParam<bool>
-    kBackupRefPtrAsanEnableExtractionCheckParam;
-extern const BASE_EXPORT base::FeatureParam<bool>
-    kBackupRefPtrAsanEnableInstantiationCheckParam;
-extern const BASE_EXPORT base::FeatureParam<AlternateBucketDistributionMode>
-    kPartitionAllocAlternateBucketDistributionParam;
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(BackupRefPtrEnabledProcesses,
+                                       kBackupRefPtrEnabledProcessesParam);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(BackupRefPtrMode,
+                                       kBackupRefPtrModeParam);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(int,
+                                       kBackupRefPtrExtraExtrasSizeParam);
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocMemoryTagging);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(MemtagMode, kMemtagModeParam);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(RetagMode, kRetagModeParam);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(MemoryTaggingEnabledProcesses,
+                                       kMemoryTaggingEnabledProcessesParam);
+// Kill switch for memory tagging. Skips any code related to memory tagging when
+// enabled.
+BASE_EXPORT BASE_DECLARE_FEATURE(kKillPartitionAllocMemoryTagging);
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocPermissiveMte);
+BASE_EXPORT BASE_DECLARE_FEATURE(kAsanBrpDereferenceCheck);
+BASE_EXPORT BASE_DECLARE_FEATURE(kAsanBrpExtractionCheck);
+BASE_EXPORT BASE_DECLARE_FEATURE(kAsanBrpInstantiationCheck);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(BucketDistributionMode,
+                                       kPartitionAllocBucketDistributionParam);
 
-BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocPCScanMUAwareScheduler);
-BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocPCScanStackScanning);
-BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocDCScan);
-BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocPCScanImmediateFreeing);
-BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocPCScanEagerClearing);
+BASE_EXPORT BASE_DECLARE_FEATURE(kLowerPAMemoryLimitForNonMainRenderers);
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocUseDenserDistribution);
+
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocMemoryReclaimer);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(TimeDelta,
+                                       kPartitionAllocMemoryReclaimerInterval);
+BASE_EXPORT BASE_DECLARE_FEATURE(
+    kPartitionAllocStraightenLargerSlotSpanFreeLists);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(
+    partition_alloc::StraightenLargerSlotSpanFreeListsMode,
+    kPartitionAllocStraightenLargerSlotSpanFreeListsMode);
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocSortSmallerSlotSpanFreeLists);
 BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocSortActiveSlotSpans);
-BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocUseAlternateDistribution);
+
 #if BUILDFLAG(IS_WIN)
 BASE_EXPORT BASE_DECLARE_FEATURE(kPageAllocatorRetryOnCommitFailure);
 #endif
 
-}  // namespace features
-}  // namespace base
+#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_CHROMEOS)
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(
+    bool,
+    kPartialLowEndModeExcludePartitionAllocSupport);
+#endif
+
+BASE_EXPORT BASE_DECLARE_FEATURE(kEnableConfigurableThreadCacheMultiplier);
+BASE_EXPORT double GetThreadCacheMultiplier();
+BASE_EXPORT double GetThreadCacheMultiplierForAndroid();
+
+BASE_EXPORT BASE_DECLARE_FEATURE(kEnableConfigurableThreadCachePurgeInterval);
+extern const partition_alloc::internal::base::TimeDelta
+GetThreadCacheMinPurgeInterval();
+extern const partition_alloc::internal::base::TimeDelta
+GetThreadCacheMaxPurgeInterval();
+extern const partition_alloc::internal::base::TimeDelta
+GetThreadCacheDefaultPurgeInterval();
+
+BASE_EXPORT BASE_DECLARE_FEATURE(
+    kEnableConfigurableThreadCacheMinCachedMemoryForPurging);
+BASE_EXPORT int GetThreadCacheMinCachedMemoryForPurgingBytes();
+
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocDisableBRPInBufferPartition);
+
+// When set, partitions use a larger ring buffer and free memory less
+// aggressively when in the foreground.
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocAdjustSizeWhenInForeground);
+
+// When enabled, uses a more nuanced heuristic to determine if slot
+// spans can be treated as "single-slot."
+//
+// See also: https://crbug.com/333443437
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocUseSmallSingleSlotSpans);
+
+#if PA_CONFIG(ENABLE_SHADOW_METADATA)
+using ShadowMetadataEnabledProcesses = internal::PAFeatureEnabledProcesses;
+
+BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocShadowMetadata);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(ShadowMetadataEnabledProcesses,
+                                       kShadowMetadataEnabledProcessesParam);
+#endif  // PA_CONFIG(ENABLE_SHADOW_METADATA)
+
+}  // namespace base::features
 
 #endif  // BASE_ALLOCATOR_PARTITION_ALLOC_FEATURES_H_

src/base/allocator/partition_alloc_support.h

@@ -8,17 +8,17 @@
 #include <map>
 #include <string>
 
-#include "base/allocator/partition_allocator/partition_alloc_config.h"
 #include "base/base_export.h"
+#include "base/feature_list.h"
 #include "base/memory/scoped_refptr.h"
+#include "base/synchronization/lock.h"
 #include "base/task/sequenced_task_runner.h"
+#include "base/thread_annotations.h"
+#include "partition_alloc/buildflags.h"
+#include "partition_alloc/partition_alloc_config.h"
+#include "partition_alloc/thread_cache.h"
 
-namespace base {
-namespace allocator {
-
-#if defined(PA_ALLOW_PCSCAN)
-BASE_EXPORT void RegisterPCScanStatsReporter();
-#endif
+namespace base::allocator {
 
 // Starts a periodic timer on the current thread to purge all thread caches.
 BASE_EXPORT void StartThreadCachePeriodicPurge();
@@ -37,7 +37,127 @@ BASE_EXPORT std::map<std::string, std::string> ProposeSyntheticFinchTrials();
 BASE_EXPORT void InstallDanglingRawPtrChecks();
 BASE_EXPORT void InstallUnretainedDanglingRawPtrChecks();
 
-}  // namespace allocator
-}  // namespace base
+// Once called, makes `free()` do nothing. This is done to reduce
+// shutdown hangs on CrOS.
+// Does nothing if Dangling Pointer Detector (`docs/dangling_ptr.md`)
+// is not active.
+// Does nothing if allocator shim support is not built.
+BASE_EXPORT void MakeFreeNoOp();
+
+// Allows to re-configure PartitionAlloc at run-time.
+class BASE_EXPORT PartitionAllocSupport {
+ public:
+  struct BrpConfiguration {
+    bool enable_brp = false;
+
+    // TODO(https://crbug.com/371135823): Remove after the investigation.
+    size_t extra_extras_size = 0;
+  };
+
+  // Reconfigure* functions re-configure PartitionAlloc. It is impossible to
+  // configure PartitionAlloc before/at its initialization using information not
+  // known at compile-time (e.g. process type, Finch), because by the time this
+  // information is available memory allocations would have surely happened,
+  // that requiring a functioning allocator.
+  //
+  // *Earlyish() is called as early as it is reasonably possible.
+  // *AfterZygoteFork() is its complement to finish configuring process-specific
+  // stuff that had to be postponed due to *Earlyish() being called with
+  // |process_type==kZygoteProcess|.
+  // *AfterFeatureListInit() is called in addition to the above, once
+  // FeatureList has been initialized and ready to use. It is guaranteed to be
+  // called on non-zygote processes or after the zygote has been forked.
+  // *AfterTaskRunnerInit() is called once it is possible to post tasks, and
+  // after the previous steps.
+  //
+  // *Earlyish() must be called exactly once. *AfterZygoteFork() must be called
+  // once iff *Earlyish() was called before with |process_type==kZygoteProcess|.
+  //
+  // *AfterFeatureListInit() may be called more than once, but will perform its
+  // re-configuration steps exactly once.
+  //
+  // *AfterTaskRunnerInit() may be called more than once.
+  void ReconfigureForTests();
+  void ReconfigureEarlyish(const std::string& process_type);
+  void ReconfigureAfterZygoteFork(const std::string& process_type);
+  void ReconfigureAfterFeatureListInit(
+      const std::string& process_type,
+      bool configure_dangling_pointer_detector = true);
+  void ReconfigureAfterTaskRunnerInit(const std::string& process_type);
+
+  // |has_main_frame| tells us if the renderer contains a main frame.
+  // The default value is intended for other process types, where the parameter
+  // does not make sense.
+  void OnForegrounded(bool has_main_frame = false);
+  void OnBackgrounded();
+
+#if PA_BUILDFLAG(ENABLE_DANGLING_RAW_PTR_CHECKS)
+  static std::string ExtractDanglingPtrSignatureForTests(
+      std::string stacktrace);
+#endif
+
+  static PartitionAllocSupport* Get();
+
+  static BrpConfiguration GetBrpConfiguration(const std::string& process_type);
+
+  // Returns true if memory tagging should be enabled if available for the given
+  // process type. May be called multiple times per process.
+  static bool ShouldEnableMemoryTagging(const std::string& process_type);
+
+  // For calling from within third_party/blink/.
+  static bool ShouldEnableMemoryTaggingInRendererProcess();
+
+  // Returns true if PA advanced checks should be enabled if available for the
+  // given process type. May be called multiple times per process.
+  static bool ShouldEnablePartitionAllocWithAdvancedChecks(
+      const std::string& process_type);
+
+ private:
+  PartitionAllocSupport();
+
+  base::Lock lock_;
+  bool called_for_tests_ GUARDED_BY(lock_) = false;
+  bool called_earlyish_ GUARDED_BY(lock_) = false;
+  bool called_after_zygote_fork_ GUARDED_BY(lock_) = false;
+  bool called_after_feature_list_init_ GUARDED_BY(lock_) = false;
+  bool called_after_thread_pool_init_ GUARDED_BY(lock_) = false;
+  std::string established_process_type_ GUARDED_BY(lock_) = "INVALID";
+
+#if PA_CONFIG(THREAD_CACHE_SUPPORTED) && \
+    PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
+  size_t largest_cached_size_ =
+      ::partition_alloc::kThreadCacheDefaultSizeThreshold;
+#endif
+};
+
+BASE_EXPORT BASE_DECLARE_FEATURE(kDisableMemoryReclaimerInBackground);
+
+// Visible in header for testing.
+class BASE_EXPORT MemoryReclaimerSupport {
+ public:
+  static MemoryReclaimerSupport& Instance();
+  MemoryReclaimerSupport();
+  ~MemoryReclaimerSupport();
+  void Start(scoped_refptr<TaskRunner> task_runner);
+  void SetForegrounded(bool in_foreground);
+
+  void ResetForTesting();
+  bool has_pending_task_for_testing() const { return has_pending_task_; }
+  static TimeDelta GetInterval();
+
+  // Visible for testing
+  static constexpr base::TimeDelta kFirstPAPurgeOrReclaimDelay =
+      base::Minutes(1);
+
+ private:
+  void Run();
+  void MaybeScheduleTask(TimeDelta delay = TimeDelta());
+
+  scoped_refptr<TaskRunner> task_runner_;
+  bool in_foreground_ = true;
+  bool has_pending_task_ = false;
+};
+
+}  // namespace base::allocator
 
 #endif  // BASE_ALLOCATOR_PARTITION_ALLOC_SUPPORT_H_

src/base/allocator/partition_allocator/.clang-tidy

@@ -0,0 +1,7 @@
+---
+  Checks: 'google-build-namespaces,
+           readability-redundant-smartptr-get,
+           readability-static-accessed-through-instance'
+  InheritParentConfig: true
+  HeaderFilterRegex: 'partition_alloc/*'
+...

src/base/allocator/partition_allocator/.gn

@@ -1,10 +1,8 @@
-# Copyright 2022 The Chromium Authors
+# Copyright 2024 The Chromium Authors
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-# The python interpreter to use by default. On Windows, this will look
-# for python3.exe and python3.bat.
-script_executable = "python3"
+# This is partition_alloc root GN configuration. It is used when built as a
+# standalone project. This is not used in production.
 
-# The location of the build configuration file.
-buildconfig = "//build/config/BUILDCONFIG.gn"
+buildconfig = "//gn/BUILDCONFIG.gn"

src/base/allocator/partition_allocator/BUILD.gn

@@ -1,463 +1,24 @@
-# Copyright 2022 The Chromium Authors
+# Copyright 2023 The Chromium Authors
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
+import("partition_alloc.gni")
 
-import("//base/allocator/partition_allocator/partition_alloc.gni")
-import("//build/buildflag_header.gni")
-import("//build/config/chromecast_build.gni")
-import("//build/config/chromeos/ui_mode.gni")
-import("//build/config/dcheck_always_on.gni")
-import("//build/config/logging.gni")
-
-# Add partition_alloc.gni and import it for partition_alloc configs.
-
-config("partition_alloc_implementation") {
-  # See also: `partition_alloc_base/component_export.h`
-  defines = [ "IS_PARTITION_ALLOC_IMPL" ]
-}
-
-config("memory_tagging") {
-  if (current_cpu == "arm64" && is_clang &&
-      (is_linux || is_chromeos || is_android || is_fuchsia)) {
-    # base/ has access to the MTE intrinsics because it needs to use them,
-    # but they're not backwards compatible. Use base::CPU::has_mte()
-    # beforehand to confirm or use indirect functions (ifuncs) to select
-    # an MTE-specific implementation at dynamic link-time.
-    cflags = [
-      "-Xclang",
-      "-target-feature",
-      "-Xclang",
-      "+mte",
-    ]
-  }
-}
-
-if (is_fuchsia) {
-  config("fuchsia_sync_lib") {
-    libs = [
-      "sync",  # Used by spinning_mutex.h.
-    ]
-  }
-}
-
-if (enable_pkeys && is_debug) {
-  config("no_stack_protector") {
-    cflags = [ "-fno-stack-protector" ]
-  }
-}
-
-component("partition_alloc") {
-  sources = [
-    "address_pool_manager.cc",
-    "address_pool_manager.h",
-    "address_pool_manager_bitmap.cc",
-    "address_pool_manager_bitmap.h",
-    "address_pool_manager_types.h",
-    "address_space_randomization.cc",
-    "address_space_randomization.h",
-    "address_space_stats.h",
-    "allocation_guard.cc",
-    "allocation_guard.h",
-    "compressed_pointer.cc",
-    "compressed_pointer.h",
-    "dangling_raw_ptr_checks.cc",
-    "dangling_raw_ptr_checks.h",
-    "freeslot_bitmap.h",
-    "freeslot_bitmap_constants.h",
-    "gwp_asan_support.cc",
-    "gwp_asan_support.h",
-    "memory_reclaimer.cc",
-    "memory_reclaimer.h",
-    "oom.cc",
-    "oom.h",
-    "oom_callback.cc",
-    "oom_callback.h",
-    "page_allocator.cc",
-    "page_allocator.h",
-    "page_allocator_constants.h",
-    "page_allocator_internal.h",
-    "partition_address_space.cc",
-    "partition_address_space.h",
-    "partition_alloc-inl.h",
-    "partition_alloc.cc",
-    "partition_alloc.h",
-    "partition_alloc_base/atomic_ref_count.h",
-    "partition_alloc_base/augmentations/compiler_specific.h",
-    "partition_alloc_base/bit_cast.h",
-    "partition_alloc_base/bits.h",
-    "partition_alloc_base/check.cc",
-    "partition_alloc_base/check.h",
-    "partition_alloc_base/compiler_specific.h",
-    "partition_alloc_base/component_export.h",
-    "partition_alloc_base/cpu.cc",
-    "partition_alloc_base/cpu.h",
-    "partition_alloc_base/cxx17_backports.h",
-    "partition_alloc_base/debug/alias.cc",
-    "partition_alloc_base/debug/alias.h",
-    "partition_alloc_base/gtest_prod_util.h",
-    "partition_alloc_base/immediate_crash.h",
-    "partition_alloc_base/logging.cc",
-    "partition_alloc_base/logging.h",
-    "partition_alloc_base/memory/ref_counted.cc",
-    "partition_alloc_base/memory/ref_counted.h",
-    "partition_alloc_base/memory/scoped_policy.h",
-    "partition_alloc_base/memory/scoped_refptr.h",
-    "partition_alloc_base/migration_adapter.h",
-    "partition_alloc_base/no_destructor.h",
-    "partition_alloc_base/numerics/checked_math.h",
-    "partition_alloc_base/numerics/checked_math_impl.h",
-    "partition_alloc_base/numerics/clamped_math.h",
-    "partition_alloc_base/numerics/clamped_math_impl.h",
-    "partition_alloc_base/numerics/math_constants.h",
-    "partition_alloc_base/numerics/ostream_operators.h",
-    "partition_alloc_base/numerics/ranges.h",
-    "partition_alloc_base/numerics/safe_conversions.h",
-    "partition_alloc_base/numerics/safe_conversions_arm_impl.h",
-    "partition_alloc_base/numerics/safe_conversions_impl.h",
-    "partition_alloc_base/numerics/safe_math.h",
-    "partition_alloc_base/numerics/safe_math_arm_impl.h",
-    "partition_alloc_base/numerics/safe_math_clang_gcc_impl.h",
-    "partition_alloc_base/numerics/safe_math_shared_impl.h",
-    "partition_alloc_base/posix/eintr_wrapper.h",
-    "partition_alloc_base/rand_util.cc",
-    "partition_alloc_base/rand_util.h",
-    "partition_alloc_base/scoped_clear_last_error.h",
-    "partition_alloc_base/strings/stringprintf.cc",
-    "partition_alloc_base/strings/stringprintf.h",
-    "partition_alloc_base/system/sys_info.h",
-    "partition_alloc_base/thread_annotations.h",
-    "partition_alloc_base/threading/platform_thread.cc",
-    "partition_alloc_base/threading/platform_thread.h",
-    "partition_alloc_base/threading/platform_thread_ref.h",
-    "partition_alloc_base/time/time.cc",
-    "partition_alloc_base/time/time.h",
-    "partition_alloc_base/time/time_override.cc",
-    "partition_alloc_base/time/time_override.h",
-    "partition_alloc_base/types/strong_alias.h",
-    "partition_alloc_base/win/win_handle_types.h",
-    "partition_alloc_base/win/win_handle_types_list.inc",
-    "partition_alloc_base/win/windows_types.h",
-    "partition_alloc_check.h",
-    "partition_alloc_config.h",
-    "partition_alloc_constants.h",
-    "partition_alloc_forward.h",
-    "partition_alloc_hooks.cc",
-    "partition_alloc_hooks.h",
-    "partition_alloc_notreached.h",
-    "partition_bucket.cc",
-    "partition_bucket.h",
-    "partition_bucket_lookup.h",
-    "partition_cookie.h",
-    "partition_direct_map_extent.h",
-    "partition_freelist_entry.h",
-    "partition_lock.h",
-    "partition_oom.cc",
-    "partition_oom.h",
-    "partition_page.cc",
-    "partition_page.h",
-    "partition_ref_count.h",
-    "partition_root.cc",
-    "partition_root.h",
-    "partition_stats.cc",
-    "partition_stats.h",
-    "partition_tag.h",
-    "partition_tag_bitmap.h",
-    "partition_tag_types.h",
-    "partition_tls.h",
-    "pkey.cc",
-    "pkey.h",
-    "random.cc",
-    "random.h",
-    "reservation_offset_table.cc",
-    "reservation_offset_table.h",
-    "reverse_bytes.h",
-    "spinning_mutex.cc",
-    "spinning_mutex.h",
-    "tagging.cc",
-    "tagging.h",
-    "thread_cache.cc",
-    "thread_cache.h",
-    "yield_processor.h",
-  ]
-
-  # Add *Scan sources if building inside Chromium. Currently,
-  # we see no need to add a more dedicated buildflag for this, as
-  # we don't anticipate Chromium-external usage of *Scan.
-  if (build_with_chromium) {
-    sources += [
-      "starscan/logging.h",
-      "starscan/metadata_allocator.cc",
-      "starscan/metadata_allocator.h",
-      "starscan/pcscan.cc",
-      "starscan/pcscan.h",
-      "starscan/pcscan_internal.cc",
-      "starscan/pcscan_internal.h",
-      "starscan/pcscan_scheduling.cc",
-      "starscan/pcscan_scheduling.h",
-      "starscan/raceful_worklist.h",
-      "starscan/scan_loop.h",
-      "starscan/snapshot.cc",
-      "starscan/snapshot.h",
-      "starscan/stack/stack.cc",
-      "starscan/stack/stack.h",
-      "starscan/starscan_fwd.h",
-      "starscan/state_bitmap.h",
-      "starscan/stats_collector.cc",
-      "starscan/stats_collector.h",
-      "starscan/stats_reporter.h",
-      "starscan/write_protector.cc",
-      "starscan/write_protector.h",
-    ]
-  }
-
-  defines = []
-  if (is_win) {
-    sources += [
-      "page_allocator_internals_win.h",
-      "partition_alloc_base/rand_util_win.cc",
-      "partition_alloc_base/scoped_clear_last_error_win.cc",
-      "partition_alloc_base/threading/platform_thread_win.cc",
-      "partition_alloc_base/time/time_win.cc",
-      "partition_tls_win.cc",
-    ]
-  } else if (is_posix) {
-    sources += [
-      "page_allocator_internals_posix.cc",
-      "page_allocator_internals_posix.h",
-      "partition_alloc_base/files/file_util.h",
-      "partition_alloc_base/files/file_util_posix.cc",
-      "partition_alloc_base/posix/safe_strerror.cc",
-      "partition_alloc_base/posix/safe_strerror.h",
-      "partition_alloc_base/rand_util_posix.cc",
-      "partition_alloc_base/threading/platform_thread_internal_posix.h",
-      "partition_alloc_base/threading/platform_thread_posix.cc",
-      "partition_alloc_base/time/time_conversion_posix.cc",
-    ]
-
-    if (is_android || is_chromeos_ash) {
-      sources += [ "partition_alloc_base/time/time_android.cc" ]
-    }
-    if (is_apple) {
-      sources += [ "partition_alloc_base/time/time_mac.mm" ]
-    } else {
-      sources += [ "partition_alloc_base/time/time_now_posix.cc" ]
-    }
-  } else if (is_fuchsia) {
-    sources += [
-      "page_allocator_internals_fuchsia.h",
-      "partition_alloc_base/fuchsia/fuchsia_logging.cc",
-      "partition_alloc_base/fuchsia/fuchsia_logging.h",
-      "partition_alloc_base/posix/safe_strerror.cc",
-      "partition_alloc_base/posix/safe_strerror.h",
-      "partition_alloc_base/rand_util_fuchsia.cc",
-      "partition_alloc_base/threading/platform_thread_internal_posix.h",
-      "partition_alloc_base/threading/platform_thread_posix.cc",
-      "partition_alloc_base/time/time_conversion_posix.cc",
-      "partition_alloc_base/time/time_fuchsia.cc",
-    ]
-  }
-  if (is_android) {
-    # Only android build requires native_library, and native_library depends
-    # on file_path. So file_path is added if is_android = true.
-    sources += [
-      "partition_alloc_base/files/file_path.cc",
-      "partition_alloc_base/files/file_path.h",
-      "partition_alloc_base/native_library.cc",
-      "partition_alloc_base/native_library.h",
-      "partition_alloc_base/native_library_posix.cc",
-    ]
-  }
-  if (is_apple) {
-    # Apple-specific utilities
-    sources += [
-      "partition_alloc_base/mac/foundation_util.h",
-      "partition_alloc_base/mac/foundation_util.mm",
-      "partition_alloc_base/mac/scoped_cftyperef.h",
-      "partition_alloc_base/mac/scoped_typeref.h",
-    ]
-    if (is_ios) {
-      sources += [
-        "partition_alloc_base/ios/ios_util.h",
-        "partition_alloc_base/ios/ios_util.mm",
-        "partition_alloc_base/system/sys_info_ios.mm",
-      ]
-    }
-    if (is_mac) {
-      sources += [
-        "partition_alloc_base/mac/mac_util.h",
-        "partition_alloc_base/mac/mac_util.mm",
-        "partition_alloc_base/system/sys_info_mac.mm",
-      ]
-    }
-  }
-  if (build_with_chromium) {
-    if (current_cpu == "x64") {
-      defines += [ "PA_PCSCAN_STACK_SUPPORTED" ]
-      sources += [ "starscan/stack/asm/x64/push_registers_asm.cc" ]
-    } else if (current_cpu == "x86") {
-      defines += [ "PA_PCSCAN_STACK_SUPPORTED" ]
-      sources += [ "starscan/stack/asm/x86/push_registers_asm.cc" ]
-    } else if (current_cpu == "arm") {
-      defines += [ "PA_PCSCAN_STACK_SUPPORTED" ]
-      sources += [ "starscan/stack/asm/arm/push_registers_asm.cc" ]
-    } else if (current_cpu == "arm64") {
-      defines += [ "PA_PCSCAN_STACK_SUPPORTED" ]
-      sources += [ "starscan/stack/asm/arm64/push_registers_asm.cc" ]
-    } else {
-      # To support a trampoline for another arch, please refer to v8/src/heap/base.
-    }
-  }
-  public_deps = [
-    ":chromecast_buildflags",
-    ":chromeos_buildflags",
-    ":debugging_buildflags",
-    ":logging_buildflags",
-    ":partition_alloc_buildflags",
-  ]
-
-  configs += [
-    ":partition_alloc_implementation",
-    ":memory_tagging",
-  ]
-  deps = []
-  public_configs = []
-  if (is_android) {
-    # tagging.cc requires __arm_mte_set_* functions.
-    deps += [ "//third_party/android_ndk:cpu_features" ]
-  }
-  if (is_fuchsia) {
-    public_deps += [
-      "//third_party/fuchsia-sdk/sdk/pkg/fit",
-      "//third_party/fuchsia-sdk/sdk/pkg/sync",
-      "//third_party/fuchsia-sdk/sdk/pkg/zx",
-    ]
-
-    # Needed for users of spinning_mutex.h, which for performance reasons,
-    # contains inlined calls to `libsync` inside the header file.
-    # It appends an entry to the "libs" section of the dependent target.
-    public_configs += [ ":fuchsia_sync_lib" ]
-  }
-
-  frameworks = []
-  if (is_mac) {
-    # SecTaskGetCodeSignStatus needs:
-    frameworks += [ "Security.framework" ]
-  }
-
-  if (is_apple) {
-    frameworks += [
-      "CoreFoundation.framework",
-      "Foundation.framework",
-    ]
-  }
-
-  configs += [ "//build/config/compiler:wexit_time_destructors" ]
-
-  # Partition alloc is relatively hot (>1% of cycles for users of CrOS). Use speed-focused
-  # optimizations for it.
-  if (!is_debug) {
-    configs -= [ "//build/config/compiler:default_optimization" ]
-    configs += [ "//build/config/compiler:optimize_speed" ]
-  }
-
-  # We want to be able to test pkey mode without access to the default pkey.
-  # This is incompatible with stack protectors since the TLS won't be pkey-tagged.
-  if (enable_pkeys && is_debug) {
-    configs += [ ":no_stack_protector" ]
-  }
-}
-
-buildflag_header("partition_alloc_buildflags") {
-  header = "partition_alloc_buildflags.h"
-
-  _record_alloc_info = false
-
-  # GWP-ASan is tied to BRP's "refcount in previous slot" mode, whose
-  # enablement is already gated on BRP enablement.
-  _enable_gwp_asan_support = put_ref_count_in_previous_slot
-
-  # TODO(crbug.com/1151236): Need to refactor the following buildflags.
-  # The buildflags (except RECORD_ALLOC_INFO) are used by both chrome and
-  # partition alloc. For partition alloc,
-  # gen/base/allocator/partition_allocator/partition_alloc_buildflags.h
-  # defines and partition alloc includes the header file. For chrome,
-  # gen/base/allocator/buildflags.h defines and chrome includes.
-  flags = [
-    "USE_PARTITION_ALLOC=$use_partition_alloc",
-    "ENABLE_PARTITION_ALLOC_AS_MALLOC_SUPPORT=$use_partition_alloc_as_malloc",
-
-    "ENABLE_BACKUP_REF_PTR_SUPPORT=$enable_backup_ref_ptr_support",
-    "ENABLE_BACKUP_REF_PTR_SLOW_CHECKS=$enable_backup_ref_ptr_slow_checks",
-    "ENABLE_DANGLING_RAW_PTR_CHECKS=$enable_dangling_raw_ptr_checks",
-    "ENABLE_DANGLING_RAW_PTR_PERF_EXPERIMENT=$enable_dangling_raw_ptr_perf_experiment",
-    "BACKUP_REF_PTR_POISON_OOB_PTR=$backup_ref_ptr_poison_oob_ptr",
-    "PUT_REF_COUNT_IN_PREVIOUS_SLOT=$put_ref_count_in_previous_slot",
-    "USE_ASAN_BACKUP_REF_PTR=$use_asan_backup_ref_ptr",
-    "USE_ASAN_UNOWNED_PTR=$use_asan_unowned_ptr",
-    "ENABLE_GWP_ASAN_SUPPORT=$_enable_gwp_asan_support",
-
-    # Not to be used directly - instead use
-    # defined(PA_ENABLE_MTE_CHECKED_PTR_SUPPORT_WITH_64_BITS_POINTERS)
-    "ENABLE_MTE_CHECKED_PTR_SUPPORT=$enable_mte_checked_ptr_support",
-
-    "RECORD_ALLOC_INFO=$_record_alloc_info",
-    "USE_FREESLOT_BITMAP=$use_freeslot_bitmap",
-    "GLUE_CORE_POOLS=$glue_core_pools",
-    "ENABLE_POINTER_COMPRESSION=$enable_pointer_compression_support",
-    "ENABLE_SHADOW_METADATA_FOR_64_BITS_POINTERS=$enable_shadow_metadata",
-
-    # *Scan is currently only used by Chromium.
-    "STARSCAN=$build_with_chromium",
-
-    "ENABLE_PKEYS=$enable_pkeys",
-  ]
-}
-
-buildflag_header("chromecast_buildflags") {
-  header = "chromecast_buildflags.h"
-
-  flags = [
-    "PA_IS_CAST_ANDROID=$is_cast_android",
-    "PA_IS_CASTOS=$is_castos",
-  ]
-}
-
-buildflag_header("chromeos_buildflags") {
-  header = "chromeos_buildflags.h"
-
-  flags = [ "PA_IS_CHROMEOS_ASH=$is_chromeos_ash" ]
-}
-
-buildflag_header("logging_buildflags") {
-  header = "logging_buildflags.h"
-
-  flags = [ "PA_ENABLE_LOG_ERROR_NOT_REACHED=$enable_log_error_not_reached" ]
-}
-
-buildflag_header("debugging_buildflags") {
-  header = "debugging_buildflags.h"
-  header_dir = rebase_path(".", "//") + "/partition_alloc_base/debug"
-
-  # Duplicates the setup Chromium uses to define `DCHECK_IS_ON()`,
-  # but avails it as a buildflag.
-  _dcheck_is_on = is_debug || dcheck_always_on
-
-  flags = [
-    "PA_DCHECK_IS_ON=$_dcheck_is_on",
-    "PA_EXPENSIVE_DCHECKS_ARE_ON=$enable_expensive_dchecks",
-    "PA_DCHECK_IS_CONFIGURABLE=$dcheck_is_configurable",
-  ]
+group("raw_ptr") {
+  public_deps = [ "src/partition_alloc:raw_ptr" ]
 }
 
 group("buildflags") {
-  public_deps = [
-    ":chromecast_buildflags",
-    ":chromeos_buildflags",
-    ":debugging_buildflags",
-    ":logging_buildflags",
-    ":partition_alloc_buildflags",
-  ]
+  public_deps = [ "src/partition_alloc:buildflags" ]
+}
+
+if (use_partition_alloc && is_clang_or_gcc) {
+  group("partition_alloc") {
+    public_deps = [ "src/partition_alloc:partition_alloc" ]
+  }
+}
+
+if (use_allocator_shim) {
+  group("allocator_shim") {
+    public_deps = [ "src/partition_alloc:allocator_shim" ]
+  }
 }
-# TODO(crbug.com/1151236): After making partition_alloc a standalone library,
-# move test code here. i.e. test("partition_alloc_tests") { ... } and
-# test("partition_alloc_perftests").

src/base/allocator/partition_allocator/DEPS

@@ -2,156 +2,59 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-# PartitionAlloc is planned to be extracted into a standalone library, and
-# therefore dependencies need to be strictly controlled and minimized.
-
-gclient_gn_args_file = 'partition_allocator/build/config/gclient_args.gni'
-
-# Only these hosts are allowed for dependencies in this DEPS file.
-# This is a subset of chromium/src/DEPS's allowed_hosts.
-allowed_hosts = [
-  'chromium.googlesource.com',
-]
-
-vars = {
-  'chromium_git': 'https://chromium.googlesource.com',
-}
-
-deps = {
-  'partition_allocator/build':
-      Var('chromium_git') + '/chromium/src/build.git',
-  'partition_allocator/buildtools':
-      Var('chromium_git') + '/chromium/src/buildtools.git',
-  'partition_allocator/buildtools/clang_format/script':
-      Var('chromium_git') +
-      '/external/github.com/llvm/llvm-project/clang/tools/clang-format.git',
-  'partition_allocator/buildtools/linux64': {
-    'packages': [
-      {
-        'package': 'gn/gn/linux-${{arch}}',
-        'version': 'latest',
-      }
-    ],
-    'dep_type': 'cipd',
-    'condition': 'host_os == "linux"',
-  },
-  'partition_allocator/buildtools/mac': {
-    'packages': [
-      {
-        'package': 'gn/gn/mac-${{arch}}',
-        'version': 'latest',
-      }
-    ],
-    'dep_type': 'cipd',
-    'condition': 'host_os == "mac"',
-  },
-  'partition_allocator/buildtools/win': {
-    'packages': [
-      {
-        'package': 'gn/gn/windows-amd64',
-        'version': 'latest',
-      }
-    ],
-    'dep_type': 'cipd',
-    'condition': 'host_os == "win"',
-  },
-  'partition_allocator/buildtools/third_party/libc++/trunk':
-      Var('chromium_git') + '/external/github.com/llvm/llvm-project/libcxx.git',
-  'partition_allocator/buildtools/third_party/libc++abi/trunk':
-      Var('chromium_git') +
-      '/external/github.com/llvm/llvm-project/libcxxabi.git',
-  'partition_allocator/tools/clang':
-      Var('chromium_git') + '/chromium/src/tools/clang.git',
-}
-
-hooks = [
-  {
-    'name': 'sysroot_arm',
-    'pattern': '.',
-    'condition': 'checkout_linux and checkout_arm',
-    'action': [
-        'python3',
-        'partition_allocator/build/linux/sysroot_scripts/install-sysroot.py',
-        '--arch=arm'],
-  },
-  {
-    'name': 'sysroot_arm64',
-    'pattern': '.',
-    'condition': 'checkout_linux and checkout_arm64',
-    'action': [
-        'python3',
-        'partition_allocator/build/linux/sysroot_scripts/install-sysroot.py',
-        '--arch=arm64'],
-  },
-  {
-    'name': 'sysroot_x86',
-    'pattern': '.',
-    'condition': 'checkout_linux and (checkout_x86 or checkout_x64)',
-    'action': [
-        'python3',
-        'partition_allocator/build/linux/sysroot_scripts/install-sysroot.py',
-        '--arch=x86'],
-  },
-  {
-    'name': 'sysroot_mips',
-    'pattern': '.',
-    'condition': 'checkout_linux and checkout_mips',
-    'action': [
-        'python3',
-        'partition_allocator/build/linux/sysroot_scripts/install-sysroot.py',
-        '--arch=mips'],
-  },
-  {
-    'name': 'sysroot_mips64',
-    'pattern': '.',
-    'condition': 'checkout_linux and checkout_mips64',
-    'action': [
-        'python3',
-        'partition_allocator/build/linux/sysroot_scripts/install-sysroot.py',
-        '--arch=mips64el'],
-  },
-  {
-    'name': 'sysroot_x64',
-    'pattern': '.',
-    'condition': 'checkout_linux and checkout_x64',
-    'action': [
-        'python3',
-        'partition_allocator/build/linux/sysroot_scripts/install-sysroot.py',
-        '--arch=x64'],
-  },
-  {
-    # Update the prebuilt clang toolchain.
-    # Note: On Win, this should run after win_toolchain, as it may use it.
-    'name': 'clang',
-    'pattern': '.',
-    'action': ['python3', 'partition_allocator/tools/clang/scripts/update.py'],
-  },
-]
-
+# PartitionAlloc library must not depend on Chromium
+# project in order to be a standalone library.
 noparent = True
 
-include_rules = [
-    "+build/build_config.h",
-    "+build/buildflag.h",
-    "+third_party/lss/linux_syscall_support.h",
-]
+# `partition_alloc` can depend only on itself, via its `include_dirs`.
+include_rules = [ "+partition_alloc" ]
 
+# TODO(crbug.com/40158212): Depending on what is tested, split the tests in
+# between chromium and partition_alloc. Remove those exceptions:
 specific_include_rules = {
-  ".*_(perf|unit)test\.cc$": [
-    "+base/allocator/allocator_shim_default_dispatch_to_partition_alloc.h",
-    "+base/debug/proc_maps_linux.h",
-    "+base/system/sys_info.h",
-    "+base/test/gtest_util.h",
-    "+base/timer/lap_timer.h",
-    "+base/win/windows_version.h",
+  # Dependencies on //testing:
+  ".*_(perf|unit)?test.*\.(h|cc)": [
     "+testing/gmock/include/gmock/gmock.h",
     "+testing/gtest/include/gtest/gtest.h",
     "+testing/perf/perf_result_reporter.h",
   ],
-  "extended_api\.cc$": [
+  "gtest_util.h": [
+    "+testing/gtest/include/gtest/gtest.h",
+  ],
+
+  # Dependencies on //base:
+  "extended_api\.cc": [
     "+base/allocator/allocator_shim_default_dispatch_to_partition_alloc.h",
   ],
-  "gtest_prod_util\.h$": [
-    "+testing/gtest/include/gtest/gtest_prod.h",
+  "partition_alloc_perftest\.cc": [
+    "+base/allocator/dispatcher/dispatcher.h",
+    "+base/debug/allocation_trace.h",
+    "+base/debug/debugging_buildflags.h",
+    "+base/timer/lap_timer.h",
+  ],
+  "partition_lock_perftest\.cc": [
+    "+base/timer/lap_timer.h",
+  ],
+  "raw_ptr_unittest\.cc": [
+    "+base/allocator/partition_alloc_features.h",
+    "+base/allocator/partition_alloc_support.h",
+    "+base/cpu.h",
+    "+base/debug/asan_service.h",
+    "+base/metrics/histogram_base.h",
+    "+base/test/bind.h",
+    "+base/test/gtest_util.h",
+    "+base/test/memory/dangling_ptr_instrumentation.h",
+    "+base/test/scoped_feature_list.h",
+    "+base/types/to_address.h",
+  ],
+  "raw_ref_unittest\.cc": [
+    "+base/debug/asan_service.h",
+    "+base/memory/raw_ptr_asan_service.h",
+    "+base/test/gtest_util.h",
   ],
 }
+
+# In the context of a module-level DEPS, the `deps` variable must be defined.
+# Some tools relies on it. For instance dawn/tools/fetch_dawn_dependencies.py
+# This has no use in other contexts.
+deps = {}

src/base/allocator/partition_allocator/DIR_METADATA

@@ -1,6 +1,8 @@
-monorail {
+monorail: {
   component: "Blink>MemoryAllocator>Partition"
 }
-
 # Also security-dev@chromium.org
 team_email: "platform-architecture-dev@chromium.org"
+buganizer_public: {
+  component_id: 1456202
+}

src/base/allocator/partition_allocator/OWNERS

@@ -1,4 +1,7 @@
-bartekn@chromium.org
 haraken@chromium.org
+keishi@chromium.org
 lizeb@chromium.org
 tasak@google.com
+
+per-file pointers/raw_ptr*=file://base/memory/MIRACLE_PTR_OWNERS
+per-file pointers/raw_ref*=file://base/memory/MIRACLE_PTR_OWNERS

src/base/allocator/partition_allocator/PRESUBMIT.py

@@ -0,0 +1,249 @@
+# Copyright 2024 The Chromium Authors
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+"""Chromium presubmit script for base/allocator/partition_allocator.
+
+See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
+for more details on the presubmit API built into depot_tools.
+"""
+
+PRESUBMIT_VERSION = '2.0.0'
+
+# This is the base path of the partition_alloc directory when stored inside the
+# chromium repository. PRESUBMIT.py is executed from chromium.
+_PARTITION_ALLOC_BASE_PATH = 'base/allocator/partition_allocator/src/'
+
+# Pattern matching C/C++ source files, for use in allowlist args.
+_SOURCE_FILE_PATTERN = r'.*\.(h|hpp|c|cc|cpp)$'
+
+# Similar pattern, matching GN files.
+_BUILD_FILE_PATTERN = r'.*\.(gn|gni)$'
+
+# This is adapted from Chromium's PRESUBMIT.py. The differences are:
+# - Base path: It is relative to the partition_alloc's source directory instead
+#              of chromium.
+# - Stricter: A single format is allowed: `PATH_ELEM_FILE_NAME_H_`.
+def CheckForIncludeGuards(input_api, output_api):
+    """Check that header files have proper include guards"""
+
+    def guard_for_file(file):
+        local_path = file.LocalPath()
+        if input_api.is_windows:
+            local_path = local_path.replace('\\', '/')
+        assert local_path.startswith(_PARTITION_ALLOC_BASE_PATH)
+        guard = input_api.os_path.normpath(
+            local_path[len(_PARTITION_ALLOC_BASE_PATH):])
+        guard = guard + '_'
+        guard = guard.upper()
+        guard = input_api.re.sub(r'[+\\/.-]', '_', guard)
+        return guard
+
+    def is_partition_alloc_header_file(f):
+        # We only check header files.
+        return f.LocalPath().endswith('.h')
+
+    errors = []
+
+    for f in input_api.AffectedSourceFiles(is_partition_alloc_header_file):
+        expected_guard = guard_for_file(f)
+
+        # Unlike the Chromium's top-level PRESUBMIT.py, we enforce a stricter
+        # rule which accepts only `PATH_ELEM_FILE_NAME_H_` per coding style.
+        guard_name_pattern = input_api.re.escape(expected_guard)
+        guard_pattern = input_api.re.compile(r'#ifndef\s+(' +
+                                             guard_name_pattern + ')')
+
+        guard_name = None
+        guard_line_number = None
+        seen_guard_end = False
+        for line_number, line in enumerate(f.NewContents()):
+            if guard_name is None:
+                match = guard_pattern.match(line)
+                if match:
+                    guard_name = match.group(1)
+                    guard_line_number = line_number
+                continue
+
+            # The line after #ifndef should have a #define of the same name.
+            if line_number == guard_line_number + 1:
+                expected_line = '#define %s' % guard_name
+                if line != expected_line:
+                    errors.append(
+                        output_api.PresubmitPromptWarning(
+                            'Missing "%s" for include guard' % expected_line,
+                            ['%s:%d' % (f.LocalPath(), line_number + 1)],
+                            'Expected: %r\nGot: %r' % (expected_line, line)))
+
+            if not seen_guard_end and line == '#endif  // %s' % guard_name:
+                seen_guard_end = True
+                continue
+
+            if seen_guard_end:
+                if line.strip() != '':
+                    errors.append(
+                        output_api.PresubmitPromptWarning(
+                            'Include guard %s not covering the whole file' %
+                            (guard_name), [f.LocalPath()]))
+                    break  # Nothing else to check and enough to warn once.
+
+        if guard_name is None:
+            errors.append(
+                output_api.PresubmitPromptWarning(
+                    'Missing include guard in %s\n'
+                    'Recommended name: %s\n' %
+                    (f.LocalPath(), expected_guard)))
+
+    return errors
+
+# In .gn and .gni files, check there are no unexpected dependencies on files
+# located outside of the partition_alloc repository.
+#
+# This is important, because partition_alloc has no CQ bots on its own, but only
+# through the chromium's CQ.
+#
+# Only //build_overrides/ is allowed, as it provides embedders, a way to
+# overrides the default build settings and forward the dependencies to
+# partition_alloc.
+def CheckNoExternalImportInGn(input_api, output_api):
+    # Match and capture <path> from import("<path>").
+    import_re = input_api.re.compile(r'^ *import\("([^"]+)"\)')
+
+    sources = lambda affected_file: input_api.FilterSourceFile(
+        affected_file,
+        files_to_skip=[],
+        files_to_check=[_BUILD_FILE_PATTERN])
+
+    errors = []
+    for f in input_api.AffectedSourceFiles(sources):
+        for line_number, line in f.ChangedContents():
+            match = import_re.search(line)
+            if not match:
+                continue
+            import_path = match.group(1)
+            if import_path.startswith('//build_overrides/'):
+                continue
+            if not import_path.startswith('//'):
+                continue;
+            errors.append(output_api.PresubmitError(
+                '%s:%d\nPartitionAlloc disallow external import: %s' %
+                (f.LocalPath(), line_number + 1, import_path)))
+    return errors;
+
+# partition_alloc still supports C++17, because Skia still uses C++17.
+def CheckCpp17CompatibleHeaders(input_api, output_api):
+    CPP_20_HEADERS = [
+        "barrier",
+        "bit",
+        #"compare",  Three-way comparison may be used under appropriate guards.
+        "format",
+        "numbers",
+        "ranges",
+        "semaphore",
+        "source_location",
+        "span",
+        "stop_token",
+        "syncstream",
+        "version",
+    ]
+
+    CPP_23_HEADERS = [
+        "expected",
+        "flat_map",
+        "flat_set",
+        "generator",
+        "mdspan",
+        "print",
+        "spanstream",
+        "stacktrace",
+        "stdatomic.h",
+        "stdfloat",
+    ]
+
+    sources = lambda affected_file: input_api.FilterSourceFile(
+        affected_file,
+        # compiler_specific.h may use these headers in guarded ways.
+        files_to_skip=[
+            r'.*partition_alloc_base/augmentations/compiler_specific\.h'
+        ],
+        files_to_check=[_SOURCE_FILE_PATTERN])
+
+    errors = []
+    for f in input_api.AffectedSourceFiles(sources):
+        # for line_number, line in f.ChangedContents():
+        for line_number, line in enumerate(f.NewContents()):
+            for header in CPP_20_HEADERS:
+                if not "#include <%s>" % header in line:
+                    continue
+                errors.append(
+                    output_api.PresubmitError(
+                        '%s:%d\nPartitionAlloc disallows C++20 headers: <%s>'
+                        % (f.LocalPath(), line_number + 1, header)))
+            for header in CPP_23_HEADERS:
+                if not "#include <%s>" % header in line:
+                    continue
+                errors.append(
+                    output_api.PresubmitError(
+                        '%s:%d\nPartitionAlloc disallows C++23 headers: <%s>'
+                        % (f.LocalPath(), line_number + 1, header)))
+    return errors
+
+def CheckCpp17CompatibleKeywords(input_api, output_api):
+    CPP_20_KEYWORDS = [
+        "concept",
+        "consteval",
+        "constinit",
+        "co_await",
+        "co_return",
+        "co_yield",
+        "requires",
+        "std::hardware_",
+        "std::is_constant_evaluated",
+        "std::bit_cast",
+        "std::midpoint",
+        "std::to_array",
+    ]
+    # Note: C++23 doesn't introduce new keywords.
+
+    sources = lambda affected_file: input_api.FilterSourceFile(
+        affected_file,
+        # compiler_specific.h may use these keywords in guarded macros.
+        files_to_skip=[r'.*partition_alloc_base/compiler_specific\.h'],
+        files_to_check=[_SOURCE_FILE_PATTERN])
+
+    errors = []
+    for f in input_api.AffectedSourceFiles(sources):
+        for line_number, line in f.ChangedContents():
+            for keyword in CPP_20_KEYWORDS:
+                if not keyword in line:
+                    continue
+                # Skip if part of a comment
+                if '//' in line and line.index('//') < line.index(keyword):
+                    continue
+
+                # Make sure there are word separators around the keyword:
+                regex = r'\b%s\b' % keyword
+                if not input_api.re.search(regex, line):
+                    continue
+
+                errors.append(
+                    output_api.PresubmitError(
+                        '%s:%d\nPartitionAlloc disallows C++20 keywords: %s'
+                        % (f.LocalPath(), line_number + 1, keyword)))
+    return errors
+
+# Check `NDEBUG` is not used inside partition_alloc. We prefer to use the
+# buildflags `#if PA_BUILDFLAG(IS_DEBUG)` instead.
+def CheckNoNDebug(input_api, output_api):
+    sources = lambda affected_file: input_api.FilterSourceFile(
+        affected_file,
+        files_to_skip=[],
+        files_to_check=[_SOURCE_FILE_PATTERN])
+
+    errors = []
+    for f in input_api.AffectedSourceFiles(sources):
+        for line_number, line in f.ChangedContents():
+            if 'NDEBUG' in line:
+                errors.append(output_api.PresubmitError('%s:%d\nPartitionAlloc'
+                  % (f.LocalPath(), line_number + 1)
+                  + 'disallows NDEBUG, use PA_BUILDFLAG(IS_DEBUG) instead'))
+    return errors

src/base/allocator/partition_allocator/PRESUBMIT_test.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+# Copyright 2024 The Chromium Authors
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import os
+import sys
+import unittest
+
+import PRESUBMIT
+
+# Append chrome source root to import `PRESUBMIT_test_mocks.py`.
+sys.path.append(
+    os.path.dirname(
+        os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))))))
+from PRESUBMIT_test_mocks import MockAffectedFile, MockInputApi, MockOutputApi
+
+_PARTITION_ALLOC_BASE_PATH = 'base/allocator/partition_allocator/src/'
+
+
+class PartitionAllocIncludeGuardsTest(unittest.TestCase):
+
+    def _CheckForIncludeGuardsWithMock(self, filename, lines):
+        mock_input_api = MockInputApi()
+        mock_input_api.files = [MockAffectedFile(filename, lines)]
+        mock_output_api = MockOutputApi()
+        return PRESUBMIT.CheckForIncludeGuards(mock_input_api, mock_output_api)
+
+    def testExpectedGuardNameDoesNotError(self):
+        lines = [
+            '#ifndef PARTITION_ALLOC_RANDOM_H_',
+            '#define PARTITION_ALLOC_RANDOM_H_',
+            '#endif  // PARTITION_ALLOC_RANDOM_H_'
+        ]
+        errors = self._CheckForIncludeGuardsWithMock(
+            _PARTITION_ALLOC_BASE_PATH + 'partition_alloc/random.h', lines)
+        self.assertEqual(0, len(errors))
+
+    def testMissingGuardErrors(self):
+        lines = []
+        errors = self._CheckForIncludeGuardsWithMock(
+            _PARTITION_ALLOC_BASE_PATH + 'partition_alloc/random.h', lines)
+        self.assertEqual(1, len(errors))
+        self.assertIn('Missing include guard', errors[0].message)
+        self.assertIn('Recommended name: PARTITION_ALLOC_RANDOM_H_',
+                      errors[0].message)
+
+    def testMissingGuardInNonHeaderFileDoesNotError(self):
+        lines = []
+        errors = self._CheckForIncludeGuardsWithMock(
+            _PARTITION_ALLOC_BASE_PATH + 'partition_alloc/random.cc', lines)
+        self.assertEqual(0, len(errors))
+
+    def testGuardNotCoveringWholeFileErrors(self):
+        lines = [
+            '#ifndef PARTITION_ALLOC_RANDOM_H_',
+            '#define PARTITION_ALLOC_RANDOM_H_',
+            '#endif  // PARTITION_ALLOC_RANDOM_H_',
+            'int oh_i_forgot_to_guard_this;'
+        ]
+        errors = self._CheckForIncludeGuardsWithMock(
+            _PARTITION_ALLOC_BASE_PATH + 'partition_alloc/random.h', lines)
+        self.assertEqual(1, len(errors))
+        self.assertIn('not covering the whole file', errors[0].message)
+
+    def testMissingDefineInGuardErrors(self):
+        lines = [
+            '#ifndef PARTITION_ALLOC_RANDOM_H_',
+            'int somehow_put_here;'
+            '#define PARTITION_ALLOC_RANDOM_H_',
+            '#endif  // PARTITION_ALLOC_RANDOM_H_',
+        ]
+        errors = self._CheckForIncludeGuardsWithMock(
+            _PARTITION_ALLOC_BASE_PATH + 'partition_alloc/random.h', lines)
+        self.assertEqual(1, len(errors))
+        self.assertIn(
+            'Missing "#define PARTITION_ALLOC_RANDOM_H_" for include guard',
+            errors[0].message)
+
+
+if __name__ == '__main__':
+    unittest.main()

src/base/allocator/partition_allocator/PartitionAlloc.md

@@ -31,7 +31,7 @@ possibility of inlining.
 ![The central allocator manages slots and spans. It is locked on a
   per-partition basis. Separately, the thread cache consumes slots
   from the central allocator, allowing it to hand out memory
-  quickly to individual threads.](./dot/layers.png)
+  quickly to individual threads.](./src/partition_alloc/dot/layers.png)
 
 However, even the fast path isn't the fastest, because it requires taking
 a per-partition lock. Although we optimized the lock, there was still room for
@@ -81,7 +81,7 @@ PartitionAlloc guarantees that returned pointers are aligned on
 64-bit systems, and 8B on 32-bit).
 
 PartitionAlloc also supports higher levels of alignment, that can be requested
-via `PartitionAlloc::AlignedAllocWithFlags()` or platform-specific APIs (such as
+via `PartitionAlloc::AlignedAlloc()` or platform-specific APIs (such as
 `posix_memalign()`). The requested
 alignment has to be a power of two. PartitionAlloc reserves the right to round
 up the requested size to the nearest power of two, greater than or equal to the
@@ -103,7 +103,7 @@ partition page that holds metadata (32B struct per partition page).
 ![A super page is shown full of slot spans. The slot spans are logically
   strung together to form buckets. At both extremes of the super page
   are guard pages. PartitionAlloc metadata is hidden inside the
-  guard pages at the "front."](./dot/super-page.png)
+  guard pages at the "front."](./src/partition_alloc/dot/super-page.png)
 
 * The slot span numbers provide a visual hint of their size (in partition
   pages).
@@ -111,7 +111,7 @@ partition page that holds metadata (32B struct per partition page).
     * Although only five colors are shown, in reality, a super page holds
       tens of slot spans, some of which belong to the same bucket.
 * The system page that holds metadata tracks each partition page with one 32B
-  [`PartitionPage` struct][PartitionPage], which is either
+  [`PartitionPageMetadata` struct][PartitionPage], which is either
     * a [`SlotSpanMetadata`][SlotSpanMetadata] ("v"s in the diagram) or
     * a [`SubsequentPageMetadata`][SubsequentPageMetadata] ("+"s in the
       diagram).
@@ -119,7 +119,7 @@ partition page that holds metadata (32B struct per partition page).
   of each super page).
 * In some configurations, PartitionAlloc stores more metadata than can
   fit in the one system page at the front. These are the bitmaps for
-  StarScan and `MTECheckedPtr<T>`, and they are relegated to the head of
+  `MTECheckedPtr<T>`, and they are relegated to the head of
   what would otherwise be usable space for slot spans. One, both, or
   none of these bitmaps may be present, depending on build
   configuration, runtime configuration, and type of allocation.
@@ -192,12 +192,12 @@ There is no need for a full span list. The lists are updated lazily. An empty,
 decommitted or full span may stay on the active list for some time, until
 `PartitionBucket::SetNewActiveSlotSpan()` encounters it.
 A decommitted span may stay on the empty list for some time,
-until `PartitionBucket<thread_safe>::SlowPathAlloc()` encounters it. However,
+until `PartitionBucket::SlowPathAlloc()` encounters it. However,
 the inaccuracy can't happen in the other direction, i.e. an active span can only
 be on the active list, and an empty span can only be on the active or empty
 list.
 
-[PartitionPage]: https://source.chromium.org/chromium/chromium/src/+/main:base/allocator/partition_allocator/partition_page.h;l=314;drc=e5b03e85ea180d1d1ab0dec471c7fd5d1706a9e4
-[SlotSpanMetadata]: https://source.chromium.org/chromium/chromium/src/+/main:base/allocator/partition_allocator/partition_page.h;l=120;drc=e5b03e85ea180d1d1ab0dec471c7fd5d1706a9e4
-[SubsequentPageMetadata]: https://source.chromium.org/chromium/chromium/src/+/main:base/allocator/partition_allocator/partition_page.h;l=295;drc=e5b03e85ea180d1d1ab0dec471c7fd5d1706a9e4
-[payload-start]: https://source.chromium.org/chromium/chromium/src/+/35b2deed603dedd4abb37f204d516ed62aa2b85c:base/allocator/partition_allocator/partition_page.h;l=454
+[PartitionPage]: https://source.chromium.org/search?q=-file:third_party/(angle|dawn)%20class:PartitionPageMetadata%20file:partition_page.h&ss=chromium
+[SlotSpanMetadata]: https://source.chromium.org/search?q=-file:third_party/(angle|dawn)%20class:SlotSpanMetadata%20file:partition_page.h&ss=chromium
+[SubsequentPageMetadata]: https://source.chromium.org/search?q=-file:third_party/(angle|dawn)%20class:SubsequentPageMetadata%20file:partition_page.h&ss=chromium
+[payload-start]: https://source.chromium.org/search?q=-file:third_party%2F(angle%7Cdawn)%20content:SuperPagePayloadBegin%20file:partition_page.h&ss=chromium

src/base/allocator/partition_allocator/address_pool_manager.h

@@ -1,178 +0,0 @@
-// Copyright 2020 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_ALLOCATOR_PARTITION_ALLOCATOR_ADDRESS_POOL_MANAGER_H_
-#define BASE_ALLOCATOR_PARTITION_ALLOCATOR_ADDRESS_POOL_MANAGER_H_
-
-#include <bitset>
-#include <limits>
-
-#include "base/allocator/partition_allocator/address_pool_manager_bitmap.h"
-#include "base/allocator/partition_allocator/address_pool_manager_types.h"
-#include "base/allocator/partition_allocator/partition_address_space.h"
-#include "base/allocator/partition_allocator/partition_alloc_base/compiler_specific.h"
-#include "base/allocator/partition_allocator/partition_alloc_base/component_export.h"
-#include "base/allocator/partition_allocator/partition_alloc_base/debug/debugging_buildflags.h"
-#include "base/allocator/partition_allocator/partition_alloc_base/thread_annotations.h"
-#include "base/allocator/partition_allocator/partition_alloc_check.h"
-#include "base/allocator/partition_allocator/partition_alloc_config.h"
-#include "base/allocator/partition_allocator/partition_alloc_constants.h"
-#include "base/allocator/partition_allocator/partition_lock.h"
-#include "build/build_config.h"
-
-namespace partition_alloc {
-
-class AddressSpaceStatsDumper;
-struct AddressSpaceStats;
-struct PoolStats;
-
-}  // namespace partition_alloc
-
-namespace partition_alloc::internal {
-
-// (64bit version)
-// AddressPoolManager takes a reserved virtual address space and manages address
-// space allocation.
-//
-// AddressPoolManager (currently) supports up to 4 pools. Each pool manages a
-// contiguous reserved address space. Alloc() takes a pool_handle and returns
-// address regions from the specified pool. Free() also takes a pool_handle and
-// returns the address region back to the manager.
-//
-// (32bit version)
-// AddressPoolManager wraps AllocPages and FreePages and remembers allocated
-// address regions using bitmaps. IsManagedByPartitionAlloc*Pool use the bitmaps
-// to judge whether a given address is in a pool that supports BackupRefPtr or
-// in a pool that doesn't. All PartitionAlloc allocations must be in either of
-// the pools.
-class PA_COMPONENT_EXPORT(PARTITION_ALLOC) AddressPoolManager {
- public:
-  static AddressPoolManager& GetInstance();
-
-  AddressPoolManager(const AddressPoolManager&) = delete;
-  AddressPoolManager& operator=(const AddressPoolManager&) = delete;
-
-#if defined(PA_HAS_64_BITS_POINTERS)
-  void Add(pool_handle handle, uintptr_t address, size_t length);
-  void Remove(pool_handle handle);
-
-  // Populate a |used| bitset of superpages currently in use.
-  void GetPoolUsedSuperPages(pool_handle handle,
-                             std::bitset<kMaxSuperPagesInPool>& used);
-
-  // Return the base address of a pool.
-  uintptr_t GetPoolBaseAddress(pool_handle handle);
-#endif
-
-  // Reserves address space from the pool.
-  uintptr_t Reserve(pool_handle handle,
-                    uintptr_t requested_address,
-                    size_t length);
-
-  // Frees address space back to the pool and decommits underlying system pages.
-  void UnreserveAndDecommit(pool_handle handle,
-                            uintptr_t address,
-                            size_t length);
-  void ResetForTesting();
-
-#if !defined(PA_HAS_64_BITS_POINTERS)
-  void MarkUsed(pool_handle handle, uintptr_t address, size_t size);
-  void MarkUnused(pool_handle handle, uintptr_t address, size_t size);
-
-  static bool IsManagedByRegularPool(uintptr_t address) {
-    return AddressPoolManagerBitmap::IsManagedByRegularPool(address);
-  }
-
-  static bool IsManagedByBRPPool(uintptr_t address) {
-    return AddressPoolManagerBitmap::IsManagedByBRPPool(address);
-  }
-#endif  // !defined(PA_HAS_64_BITS_POINTERS)
-
-  void DumpStats(AddressSpaceStatsDumper* dumper);
-
- private:
-  friend class AddressPoolManagerForTesting;
-#if BUILDFLAG(ENABLE_PKEYS)
-  // If we use a pkey pool, we need to tag its metadata with the pkey. Allow the
-  // function to get access to the pool pointer.
-  friend void TagGlobalsWithPkey(int pkey);
-#endif
-
-  constexpr AddressPoolManager() = default;
-  ~AddressPoolManager() = default;
-
-  // Populates `stats` if applicable.
-  // Returns whether `stats` was populated. (They might not be, e.g.
-  // if PartitionAlloc is wholly unused in this process.)
-  bool GetStats(AddressSpaceStats* stats);
-
-#if defined(PA_HAS_64_BITS_POINTERS)
-  class Pool {
-   public:
-    constexpr Pool() = default;
-    ~Pool() = default;
-
-    Pool(const Pool&) = delete;
-    Pool& operator=(const Pool&) = delete;
-
-    void Initialize(uintptr_t ptr, size_t length);
-    bool IsInitialized();
-    void Reset();
-
-    uintptr_t FindChunk(size_t size);
-    void FreeChunk(uintptr_t address, size_t size);
-
-    bool TryReserveChunk(uintptr_t address, size_t size);
-
-    void GetUsedSuperPages(std::bitset<kMaxSuperPagesInPool>& used);
-    uintptr_t GetBaseAddress();
-
-    void GetStats(PoolStats* stats);
-
-   private:
-    Lock lock_;
-
-    // The bitset stores the allocation state of the address pool. 1 bit per
-    // super-page: 1 = allocated, 0 = free.
-    std::bitset<kMaxSuperPagesInPool> alloc_bitset_ PA_GUARDED_BY(lock_);
-
-    // An index of a bit in the bitset before which we know for sure there all
-    // 1s. This is a best-effort hint in the sense that there still may be lots
-    // of 1s after this index, but at least we know there is no point in
-    // starting the search before it.
-    size_t bit_hint_ PA_GUARDED_BY(lock_) = 0;
-
-    size_t total_bits_ = 0;
-    uintptr_t address_begin_ = 0;
-#if BUILDFLAG(PA_DCHECK_IS_ON)
-    uintptr_t address_end_ = 0;
-#endif
-  };
-
-  PA_ALWAYS_INLINE Pool* GetPool(pool_handle handle) {
-    PA_DCHECK(0 < handle && handle <= kNumPools);
-    return &aligned_pools_.pools_[handle - 1];
-  }
-
-  // Gets the stats for the pool identified by `handle`, if
-  // initialized.
-  void GetPoolStats(pool_handle handle, PoolStats* stats);
-
-  // If pkey support is enabled, we need to pkey-tag the pkey pool (which needs
-  // to be last). For this, we need to add padding in front of the pools so that
-  // pkey one starts on a page boundary.
-  struct {
-    char pad_[PA_PKEY_ARRAY_PAD_SZ(Pool, kNumPools)] = {};
-    Pool pools_[kNumPools];
-    char pad_after_[PA_PKEY_FILL_PAGE_SZ(sizeof(Pool))] = {};
-  } aligned_pools_ PA_PKEY_ALIGN;
-
-#endif  // defined(PA_HAS_64_BITS_POINTERS)
-
-  static PA_CONSTINIT AddressPoolManager singleton_;
-};
-
-}  // namespace partition_alloc::internal
-
-#endif  // BASE_ALLOCATOR_PARTITION_ALLOCATOR_ADDRESS_POOL_MANAGER_H_

src/base/allocator/partition_allocator/address_pool_manager_bitmap.cc

@@ -1,37 +0,0 @@
-// Copyright 2021 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/allocator/partition_allocator/address_pool_manager_bitmap.h"
-
-#include "base/allocator/partition_allocator/partition_alloc_buildflags.h"
-#include "base/allocator/partition_allocator/partition_alloc_constants.h"
-
-#if !defined(PA_HAS_64_BITS_POINTERS)
-
-namespace partition_alloc::internal {
-
-namespace {
-
-Lock g_lock;
-
-}  // namespace
-
-Lock& AddressPoolManagerBitmap::GetLock() {
-  return g_lock;
-}
-
-std::bitset<AddressPoolManagerBitmap::kRegularPoolBits>
-    AddressPoolManagerBitmap::regular_pool_bits_;  // GUARDED_BY(GetLock())
-std::bitset<AddressPoolManagerBitmap::kBRPPoolBits>
-    AddressPoolManagerBitmap::brp_pool_bits_;  // GUARDED_BY(GetLock())
-#if BUILDFLAG(ENABLE_BACKUP_REF_PTR_SUPPORT)
-std::array<std::atomic_bool,
-           AddressPoolManagerBitmap::kAddressSpaceSize / kSuperPageSize>
-    AddressPoolManagerBitmap::brp_forbidden_super_page_map_;
-std::atomic_size_t AddressPoolManagerBitmap::blocklist_hit_count_;
-#endif  // BUILDFLAG(ENABLE_BACKUP_REF_PTR_SUPPORT)
-
-}  // namespace partition_alloc::internal
-
-#endif  // !defined(PA_HAS_64_BITS_POINTERS)

src/base/allocator/partition_allocator/address_pool_manager_types.h

@@ -1,14 +0,0 @@
-// Copyright 2020 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_ALLOCATOR_PARTITION_ALLOCATOR_ADDRESS_POOL_MANAGER_TYPES_H_
-#define BASE_ALLOCATOR_PARTITION_ALLOCATOR_ADDRESS_POOL_MANAGER_TYPES_H_
-
-namespace partition_alloc::internal {
-
-using pool_handle = unsigned;
-
-}  // namespace partition_alloc::internal
-
-#endif  // BASE_ALLOCATOR_PARTITION_ALLOCATOR_ADDRESS_POOL_MANAGER_TYPES_H_

src/base/allocator/partition_allocator/address_space_randomization.cc

@@ -1,67 +0,0 @@
-// Copyright 2014 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/allocator/partition_allocator/address_space_randomization.h"
-
-#include "base/allocator/partition_allocator/partition_alloc_check.h"
-#include "base/allocator/partition_allocator/partition_alloc_config.h"
-#include "base/allocator/partition_allocator/random.h"
-#include "build/build_config.h"
-
-#if BUILDFLAG(IS_WIN)
-#include <windows.h>  // Must be in front of other Windows header files.
-
-#include <versionhelpers.h>
-#endif
-
-namespace partition_alloc {
-
-uintptr_t GetRandomPageBase() {
-  uintptr_t random = static_cast<uintptr_t>(internal::RandomValue());
-
-#if defined(PA_HAS_64_BITS_POINTERS)
-  random <<= 32ULL;
-  random |= static_cast<uintptr_t>(internal::RandomValue());
-
-// The ASLRMask() and ASLROffset() constants will be suitable for the
-// OS and build configuration.
-#if BUILDFLAG(IS_WIN) && !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
-  // Windows >= 8.1 has the full 47 bits. Use them where available.
-  static bool windows_81 = false;
-  static bool windows_81_initialized = false;
-  if (!windows_81_initialized) {
-    windows_81 = IsWindows8Point1OrGreater();
-    windows_81_initialized = true;
-  }
-  if (!windows_81) {
-    random &= internal::ASLRMaskBefore8_10();
-  } else {
-    random &= internal::ASLRMask();
-  }
-  random += internal::ASLROffset();
-#else
-  random &= internal::ASLRMask();
-  random += internal::ASLROffset();
-#endif  // BUILDFLAG(IS_WIN) && !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
-#else   // defined(PA_HAS_64_BITS_POINTERS)
-#if BUILDFLAG(IS_WIN)
-  // On win32 host systems the randomization plus huge alignment causes
-  // excessive fragmentation. Plus most of these systems lack ASLR, so the
-  // randomization isn't buying anything. In that case we just skip it.
-  // TODO(palmer): Just dump the randomization when HE-ASLR is present.
-  static BOOL is_wow64 = -1;
-  if (is_wow64 == -1 && !IsWow64Process(GetCurrentProcess(), &is_wow64))
-    is_wow64 = FALSE;
-  if (!is_wow64)
-    return 0;
-#endif  // BUILDFLAG(IS_WIN)
-  random &= internal::ASLRMask();
-  random += internal::ASLROffset();
-#endif  // defined(PA_HAS_64_BITS_POINTERS)
-
-  PA_DCHECK(!(random & internal::PageAllocationGranularityOffsetMask()));
-  return random;
-}
-
-}  // namespace partition_alloc

src/base/allocator/partition_allocator/address_space_randomization.h

@@ -1,290 +0,0 @@
-// Copyright 2014 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_ALLOCATOR_PARTITION_ALLOCATOR_ADDRESS_SPACE_RANDOMIZATION_H_
-#define BASE_ALLOCATOR_PARTITION_ALLOCATOR_ADDRESS_SPACE_RANDOMIZATION_H_
-
-#include <cstdint>
-
-#include "base/allocator/partition_allocator/page_allocator_constants.h"
-#include "base/allocator/partition_allocator/partition_alloc_base/compiler_specific.h"
-#include "base/allocator/partition_allocator/partition_alloc_base/component_export.h"
-#include "build/build_config.h"
-
-namespace partition_alloc {
-
-// Calculates a random preferred mapping address. In calculating an address, we
-// balance good ASLR against not fragmenting the address space too badly.
-PA_COMPONENT_EXPORT(PARTITION_ALLOC) uintptr_t GetRandomPageBase();
-
-namespace internal {
-
-PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE uintptr_t
-AslrAddress(uintptr_t mask) {
-  return mask & PageAllocationGranularityBaseMask();
-}
-PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE uintptr_t
-AslrMask(uintptr_t bits) {
-  return AslrAddress((1ULL << bits) - 1ULL);
-}
-
-// Turn off formatting, because the thicket of nested ifdefs below is
-// incomprehensible without indentation. It is also incomprehensible with
-// indentation, but the only other option is a combinatorial explosion of
-// *_{win,linux,mac,foo}_{32,64}.h files.
-//
-// clang-format off
-
-#if defined(ARCH_CPU_64_BITS)
-
-  #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
-
-    // We shouldn't allocate system pages at all for sanitizer builds. However,
-    // we do, and if random hint addresses interfere with address ranges
-    // hard-coded in those tools, bad things happen. This address range is
-    // copied from TSAN source but works with all tools. See
-    // https://crbug.com/539863.
-    PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE uintptr_t
-    ASLRMask() {
-      return AslrAddress(0x007fffffffffULL);
-    }
-    PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE uintptr_t
-    ASLROffset() {
-      return AslrAddress(0x7e8000000000ULL);
-    }
-
-  #elif BUILDFLAG(IS_WIN)
-
-    // Windows 8.10 and newer support the full 48 bit address range. Older
-    // versions of Windows only support 44 bits. Since ASLROffset() is non-zero
-    // and may cause a carry, use 47 and 43 bit masks. See
-    // http://www.alex-ionescu.com/?p=246
-    constexpr PA_ALWAYS_INLINE uintptr_t ASLRMask() {
-      return AslrMask(47);
-    }
-    constexpr PA_ALWAYS_INLINE uintptr_t ASLRMaskBefore8_10() {
-      return AslrMask(43);
-    }
-    // Try not to map pages into the range where Windows loads DLLs by default.
-    constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-      return 0x80000000ULL;
-    }
-
-  #elif BUILDFLAG(IS_APPLE)
-
-    // macOS as of 10.12.5 does not clean up entries in page map levels 3/4
-    // [PDP/PML4] created from mmap or mach_vm_allocate, even after the region
-    // is destroyed. Using a virtual address space that is too large causes a
-    // leak of about 1 wired [can never be paged out] page per call to mmap. The
-    // page is only reclaimed when the process is killed. Confine the hint to a
-    // 39-bit section of the virtual address space.
-    //
-    // This implementation adapted from
-    // https://chromium-review.googlesource.com/c/v8/v8/+/557958. The difference
-    // is that here we clamp to 39 bits, not 32.
-    //
-    // TODO(crbug.com/738925): Remove this limitation if/when the macOS behavior
-    // changes.
-    PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE uintptr_t
-    ASLRMask() {
-      return AslrMask(38);
-    }
-    PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE uintptr_t
-    ASLROffset() {
-      // Be careful, there is a zone where macOS will not map memory, at least
-      // on ARM64. From an ARM64 machine running 12.3, the range seems to be
-      // [0x1000000000, 0x7000000000). Make sure that the range we use is
-      // outside these bounds. In 12.3, there is a reserved area between
-      // MACH_VM_MIN_GPU_CARVEOUT_ADDRESS and MACH_VM_MAX_GPU_CARVEOUT_ADDRESS,
-      // which is reserved on ARM64. See these constants in XNU's source code
-      // for details (xnu-8019.80.24/osfmk/mach/arm/vm_param.h).
-      return AslrAddress(0x10000000000ULL);
-    }
-
-  #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
-
-    #if defined(ARCH_CPU_X86_64)
-
-      // Linux (and macOS) support the full 47-bit user space of x64 processors.
-      // Use only 46 to allow the kernel a chance to fulfill the request.
-      constexpr PA_ALWAYS_INLINE uintptr_t ASLRMask() {
-        return AslrMask(46);
-      }
-      constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-        return AslrAddress(0);
-      }
-
-    #elif defined(ARCH_CPU_ARM64)
-
-      #if BUILDFLAG(IS_ANDROID)
-
-      // Restrict the address range on Android to avoid a large performance
-      // regression in single-process WebViews. See https://crbug.com/837640.
-      constexpr PA_ALWAYS_INLINE uintptr_t ASLRMask() {
-        return AslrMask(30);
-      }
-      constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-        return AslrAddress(0x20000000ULL);
-      }
-
-      #elif BUILDFLAG(IS_LINUX)
-
-      // 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
-      // 39-bit as base as all setups should support this, lowered to 38-bit
-      // as ASLROffset() could cause a carry.
-      PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE uintptr_t
-      ASLRMask() {
-        return AslrMask(38);
-      }
-      PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR PA_ALWAYS_INLINE uintptr_t
-      ASLROffset() {
-        return AslrAddress(0x1000000000ULL);
-      }
-
-      #else
-
-      // ARM64 on Linux has 39-bit user space. Use 38 bits since ASLROffset()
-      // could cause a carry.
-      constexpr PA_ALWAYS_INLINE uintptr_t ASLRMask() {
-        return AslrMask(38);
-      }
-      constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-        return AslrAddress(0x1000000000ULL);
-      }
-
-      #endif
-
-    #elif defined(ARCH_CPU_PPC64)
-
-      #if BUILDFLAG(IS_AIX)
-
-        // AIX has 64 bits of virtual addressing, but we limit the address range
-        // to (a) minimize segment lookaside buffer (SLB) misses; and (b) use
-        // extra address space to isolate the mmap regions.
-        constexpr PA_ALWAYS_INLINE uintptr_t ASLRMask() {
-          return AslrMask(30);
-        }
-        constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-          return AslrAddress(0x400000000000ULL);
-        }
-
-      #elif defined(ARCH_CPU_BIG_ENDIAN)
-
-        // Big-endian Linux PPC has 44 bits of virtual addressing. Use 42.
-        constexpr PA_ALWAYS_INLINE uintptr_t ASLRMask() {
-          return AslrMask(42);
-        }
-        constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-          return AslrAddress(0);
-        }
-
-      #else  // !BUILDFLAG(IS_AIX) && !defined(ARCH_CPU_BIG_ENDIAN)
-
-        // Little-endian Linux PPC has 48 bits of virtual addressing. Use 46.
-        constexpr PA_ALWAYS_INLINE uintptr_t ASLRMask() {
-          return AslrMask(46);
-        }
-        constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-          return AslrAddress(0);
-        }
-
-      #endif  // !BUILDFLAG(IS_AIX) && !defined(ARCH_CPU_BIG_ENDIAN)
-
-    #elif defined(ARCH_CPU_S390X)
-
-      // Linux on Z uses bits 22 - 32 for Region Indexing, which translates to
-      // 42 bits of virtual addressing. Truncate to 40 bits to allow kernel a
-      // chance to fulfill the request.
-      constexpr PA_ALWAYS_INLINE uintptr_t ASLRMask() {
-        return AslrMask(40);
-      }
-      constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-        return AslrAddress(0);
-      }
-
-    #elif defined(ARCH_CPU_S390)
-
-      // 31 bits of virtual addressing. Truncate to 29 bits to allow the kernel
-      // a chance to fulfill the request.
-      constexpr PA_ALWAYS_INLINE uintptr_t ASLRMask() {
-        return AslrMask(29);
-      }
-      constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-        return AslrAddress(0);
-      }
-
-    #else  // !defined(ARCH_CPU_X86_64) && !defined(ARCH_CPU_PPC64) &&
-           // !defined(ARCH_CPU_S390X) && !defined(ARCH_CPU_S390)
-
-      // For all other POSIX variants, use 30 bits.
-      constexpr PA_ALWAYS_INLINE uintptr_t ASLRMask() {
-        return AslrMask(30);
-      }
-
-      #if BUILDFLAG(IS_SOLARIS)
-
-        // For our Solaris/illumos mmap hint, we pick a random address in the
-        // bottom half of the top half of the address space (that is, the third
-        // quarter). Because we do not MAP_FIXED, this will be treated only as a
-        // hint -- the system will not fail to mmap because something else
-        // happens to already be mapped at our random address. We deliberately
-        // set the hint high enough to get well above the system's break (that
-        // is, the heap); Solaris and illumos will try the hint and if that
-        // fails allocate as if there were no hint at all. The high hint
-        // prevents the break from getting hemmed in at low values, ceding half
-        // of the address space to the system heap.
-        constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-          return AslrAddress(0x80000000ULL);
-        }
-
-      #elif BUILDFLAG(IS_AIX)
-
-        // The range 0x30000000 - 0xD0000000 is available on AIX; choose the
-        // upper range.
-        constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-          return AslrAddress(0x90000000ULL);
-        }
-
-      #else  // !BUILDFLAG(IS_SOLARIS) && !BUILDFLAG(IS_AIX)
-
-        // The range 0x20000000 - 0x60000000 is relatively unpopulated across a
-        // variety of ASLR modes (PAE kernel, NX compat mode, etc) and on macOS
-        // 10.6 and 10.7.
-        constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-          return AslrAddress(0x20000000ULL);
-        }
-
-      #endif  // !BUILDFLAG(IS_SOLARIS) && !BUILDFLAG(IS_AIX)
-
-    #endif  // !defined(ARCH_CPU_X86_64) && !defined(ARCH_CPU_PPC64) &&
-            // !defined(ARCH_CPU_S390X) && !defined(ARCH_CPU_S390)
-
-  #endif  // BUILDFLAG(IS_POSIX)
-
-#elif defined(ARCH_CPU_32_BITS)
-
-  // This is a good range on 32-bit Windows and Android (the only platforms on
-  // which we support 32-bitness). Allocates in the 0.5 - 1.5 GiB region. There
-  // is no issue with carries here.
-  constexpr PA_ALWAYS_INLINE uintptr_t ASLRMask() {
-    return AslrMask(30);
-  }
-  constexpr PA_ALWAYS_INLINE uintptr_t ASLROffset() {
-    return AslrAddress(0x20000000ULL);
-  }
-
-#else
-
-  #error Please tell us about your exotic hardware! Sounds interesting.
-
-#endif  // defined(ARCH_CPU_32_BITS)
-
-// clang-format on
-
-}  // namespace internal
-
-}  // namespace partition_alloc
-
-#endif  // BASE_ALLOCATOR_PARTITION_ALLOCATOR_ADDRESS_SPACE_RANDOMIZATION_H_

src/base/allocator/partition_allocator/address_space_stats.h

@@ -1,55 +0,0 @@
-// Copyright 2022 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_ALLOCATOR_PARTITION_ALLOCATOR_ADDRESS_SPACE_STATS_H_
-#define BASE_ALLOCATOR_PARTITION_ALLOCATOR_ADDRESS_SPACE_STATS_H_
-
-#include <cstddef>
-
-#include "base/allocator/partition_allocator/partition_alloc_base/component_export.h"
-#include "base/allocator/partition_allocator/partition_alloc_buildflags.h"
-#include "base/allocator/partition_allocator/partition_alloc_config.h"
-
-namespace partition_alloc {
-
-// All members are measured in super pages.
-struct PoolStats {
-  size_t usage = 0;
-
-  // On 32-bit, pools are mainly logical entities, intermingled with
-  // allocations not managed by PartitionAlloc. The "largest available
-  // reservation" is not possible to measure in that case.
-#if defined(PA_HAS_64_BITS_POINTERS)
-  size_t largest_available_reservation = 0;
-#endif  // defined(PA_HAS_64_BITS_POINTERS)
-};
-
-struct AddressSpaceStats {
-  PoolStats regular_pool_stats;
-#if BUILDFLAG(ENABLE_BACKUP_REF_PTR_SUPPORT)
-  PoolStats brp_pool_stats;
-#endif  // BUILDFLAG(ENABLE_BACKUP_REF_PTR_SUPPORT)
-#if defined(PA_HAS_64_BITS_POINTERS)
-  PoolStats configurable_pool_stats;
-#else
-#if BUILDFLAG(ENABLE_BACKUP_REF_PTR_SUPPORT)
-  size_t blocklist_size;  // measured in super pages
-  size_t blocklist_hit_count;
-#endif  // BUILDFLAG(ENABLE_BACKUP_REF_PTR_SUPPORT)
-#endif  // defined(PA_HAS_64_BITS_POINTERS)
-#if BUILDFLAG(ENABLE_PKEYS)
-  PoolStats pkey_pool_stats;
-#endif
-};
-
-// Interface passed to `AddressPoolManager::DumpStats()` to mediate
-// for `AddressSpaceDumpProvider`.
-class PA_COMPONENT_EXPORT(PARTITION_ALLOC) AddressSpaceStatsDumper {
- public:
-  virtual void DumpStats(const AddressSpaceStats* address_space_stats) = 0;
-};
-
-}  // namespace partition_alloc
-
-#endif  // BASE_ALLOCATOR_PARTITION_ALLOCATOR_ADDRESS_SPACE_STATS_H_

src/base/allocator/partition_allocator/allocation_guard.cc

@@ -1,41 +0,0 @@
-// Copyright 2021 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/allocator/partition_allocator/allocation_guard.h"
-#include "base/allocator/partition_allocator/partition_alloc_base/immediate_crash.h"
-#include "base/allocator/partition_allocator/partition_alloc_config.h"
-
-#if defined(PA_HAS_ALLOCATION_GUARD)
-
-namespace partition_alloc {
-
-namespace {
-thread_local bool g_disallow_allocations;
-}  // namespace
-
-ScopedDisallowAllocations::ScopedDisallowAllocations() {
-  if (g_disallow_allocations)
-    PA_IMMEDIATE_CRASH();
-
-  g_disallow_allocations = true;
-}
-
-ScopedDisallowAllocations::~ScopedDisallowAllocations() {
-  g_disallow_allocations = false;
-}
-
-ScopedAllowAllocations::ScopedAllowAllocations() {
-  // Save the previous value, as ScopedAllowAllocations is used in all
-  // partitions, not just the malloc() ones(s).
-  saved_value_ = g_disallow_allocations;
-  g_disallow_allocations = false;
-}
-
-ScopedAllowAllocations::~ScopedAllowAllocations() {
-  g_disallow_allocations = saved_value_;
-}
-
-}  // namespace partition_alloc
-
-#endif  // defined(PA_HAS_ALLOCATION_GUARD)

src/base/allocator/partition_allocator/allocation_guard.h

@@ -1,49 +0,0 @@
-// Copyright 2021 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_ALLOCATOR_PARTITION_ALLOCATOR_ALLOCATION_GUARD_H_
-#define BASE_ALLOCATOR_PARTITION_ALLOCATOR_ALLOCATION_GUARD_H_
-
-#include "base/allocator/partition_allocator/partition_alloc_base/component_export.h"
-#include "base/allocator/partition_allocator/partition_alloc_config.h"
-#include "build/build_config.h"
-
-namespace partition_alloc {
-
-#if defined(PA_HAS_ALLOCATION_GUARD)
-
-// Disallow allocations in the scope. Does not nest.
-class PA_COMPONENT_EXPORT(PARTITION_ALLOC) ScopedDisallowAllocations {
- public:
-  ScopedDisallowAllocations();
-  ~ScopedDisallowAllocations();
-};
-
-// Disallow allocations in the scope. Does not nest.
-class PA_COMPONENT_EXPORT(PARTITION_ALLOC) ScopedAllowAllocations {
- public:
-  ScopedAllowAllocations();
-  ~ScopedAllowAllocations();
-
- private:
-  bool saved_value_;
-};
-
-#else
-
-struct [[maybe_unused]] ScopedDisallowAllocations{};
-struct [[maybe_unused]] ScopedAllowAllocations{};
-
-#endif  // defined(PA_HAS_ALLOCATION_GUARD)
-
-}  // namespace partition_alloc
-
-namespace base::internal {
-
-using ::partition_alloc::ScopedAllowAllocations;
-using ::partition_alloc::ScopedDisallowAllocations;
-
-}  // namespace base::internal
-
-#endif  // BASE_ALLOCATOR_PARTITION_ALLOCATOR_ALLOCATION_GUARD_H_