diff --git a/third_party/BUILD.gn b/third_party/BUILD.gn
index 5982217..3dd2aea 100644
--- a/third_party/BUILD.gn
+++ b/third_party/BUILD.gn
@@ -572,6 +572,7 @@
     "base/allocator/partition_allocator/page_allocator_internal.h",
     "base/allocator/partition_allocator/partition_alloc.cc",
     "base/allocator/partition_allocator/partition_alloc.h",
+    "base/allocator/partition_allocator/partition_alloc_check.h",
     "base/allocator/partition_allocator/partition_alloc_constants.h",
     "base/allocator/partition_allocator/partition_bucket.cc",
     "base/allocator/partition_allocator/partition_bucket.h",
diff --git a/third_party/base/allocator/partition_allocator/address_space_randomization.cc b/third_party/base/allocator/partition_allocator/address_space_randomization.cc
index c6f268f..18807a6 100644
--- a/third_party/base/allocator/partition_allocator/address_space_randomization.cc
+++ b/third_party/base/allocator/partition_allocator/address_space_randomization.cc
@@ -37,14 +37,14 @@
     windows_81_initialized = true;
   }
   if (!windows_81) {
-    random &= internal::kASLRMaskBefore8_10;
+    random &= internal::ASLRMaskBefore8_10();
   } else {
-    random &= internal::kASLRMask;
+    random &= internal::ASLRMask();
   }
-  random += internal::kASLROffset;
+  random += internal::ASLROffset();
 #else
-  random &= internal::kASLRMask;
-  random += internal::kASLROffset;
+  random &= internal::ASLRMask();
+  random += internal::ASLROffset();
 #endif  // defined(OS_WIN) && !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 #else   // defined(ARCH_CPU_32_BITS)
 #if defined(OS_WIN)
@@ -58,11 +58,11 @@
   if (!is_wow64)
     return nullptr;
 #endif  // defined(OS_WIN)
-  random &= internal::kASLRMask;
-  random += internal::kASLROffset;
+  random &= internal::ASLRMask();
+  random += internal::ASLROffset();
 #endif  // defined(ARCH_CPU_32_BITS)
 
-  DCHECK_EQ(0ULL, (random & kPageAllocationGranularityOffsetMask));
+  DCHECK_EQ(0ULL, (random & PageAllocationGranularityOffsetMask()));
   return reinterpret_cast<void*>(random);
 }
 
diff --git a/third_party/base/allocator/partition_allocator/address_space_randomization.h b/third_party/base/allocator/partition_allocator/address_space_randomization.h
index c6d8ca9..28c8271 100644
--- a/third_party/base/allocator/partition_allocator/address_space_randomization.h
+++ b/third_party/base/allocator/partition_allocator/address_space_randomization.h
@@ -8,6 +8,7 @@
 #include "build/build_config.h"
 #include "third_party/base/allocator/partition_allocator/page_allocator.h"
 #include "third_party/base/base_export.h"
+#include "third_party/base/compiler_specific.h"
 
 namespace pdfium {
 namespace base {
@@ -18,10 +19,12 @@
 
 namespace internal {
 
-constexpr uintptr_t AslrAddress(uintptr_t mask) {
-  return mask & kPageAllocationGranularityBaseMask;
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE uintptr_t
+AslrAddress(uintptr_t mask) {
+  return mask & PageAllocationGranularity();
 }
-constexpr uintptr_t AslrMask(uintptr_t bits) {
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE uintptr_t
+AslrMask(uintptr_t bits) {
   return AslrAddress((1ULL << bits) - 1ULL);
 }
 
@@ -41,19 +44,31 @@
     // 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.
-    constexpr uintptr_t kASLRMask = AslrAddress(0x007fffffffffULL);
-    constexpr uintptr_t kASLROffset = AslrAddress(0x7e8000000000ULL);
+    PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE uintptr_t
+    ASLRMask() {
+      return AslrAddress(0x007fffffffffULL);
+    }
+    PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE uintptr_t
+    ASLROffset() {
+      return AslrAddress(0x7e8000000000ULL);
+    }
 
   #elif defined(OS_WIN)
 
     // Windows 8.10 and newer support the full 48 bit address range. Older
-    // versions of Windows only support 44 bits. Since kASLROffset is non-zero
+    // 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 uintptr_t kASLRMask = AslrMask(47);
-    constexpr uintptr_t kASLRMaskBefore8_10 = AslrMask(43);
+    constexpr ALWAYS_INLINE uintptr_t ASLRMask() {
+      return AslrMask(47);
+    }
+    constexpr ALWAYS_INLINE uintptr_t ASLRMaskBefore8_10() {
+      return AslrMask(43);
+    }
     // Try not to map pages into the range where Windows loads DLLs by default.
-    constexpr uintptr_t kASLROffset = 0x80000000ULL;
+    constexpr ALWAYS_INLINE uintptr_t ASLROffset() {
+      return 0x80000000ULL;
+    }
 
   #elif defined(OS_APPLE)
 
@@ -70,8 +85,14 @@
     //
     // TODO(crbug.com/738925): Remove this limitation if/when the macOS behavior
     // changes.
-    constexpr uintptr_t kASLRMask = AslrMask(38);
-    constexpr uintptr_t kASLROffset = AslrAddress(0x1000000000ULL);
+    PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE uintptr_t
+    ASLRMask() {
+      return AslrMask(38);
+    }
+    PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE uintptr_t
+    ASLROffset() {
+      return AslrAddress(0x1000000000ULL);
+    }
 
   #elif defined(OS_POSIX) || defined(OS_FUCHSIA)
 
@@ -79,8 +100,12 @@
 
       // 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 uintptr_t kASLRMask = AslrMask(46);
-      constexpr uintptr_t kASLROffset = AslrAddress(0);
+      constexpr ALWAYS_INLINE uintptr_t ASLRMask() {
+        return AslrMask(46);
+      }
+      constexpr ALWAYS_INLINE uintptr_t ASLROffset() {
+        return AslrAddress(0);
+      }
 
     #elif defined(ARCH_CPU_ARM64)
 
@@ -88,15 +113,23 @@
 
       // Restrict the address range on Android to avoid a large performance
       // regression in single-process WebViews. See https://crbug.com/837640.
-      constexpr uintptr_t kASLRMask = AslrMask(30);
-      constexpr uintptr_t kASLROffset = AslrAddress(0x20000000ULL);
+      constexpr ALWAYS_INLINE uintptr_t ASLRMask() {
+        return AslrMask(30);
+      }
+      constexpr ALWAYS_INLINE uintptr_t ASLROffset() {
+        return AslrAddress(0x20000000ULL);
+      }
 
       #else
 
       // ARM64 on Linux has 39-bit user space. Use 38 bits since kASLROffset
       // could cause a carry.
-      constexpr uintptr_t kASLRMask = AslrMask(38);
-      constexpr uintptr_t kASLROffset = AslrAddress(0x1000000000ULL);
+      constexpr ALWAYS_INLINE uintptr_t ASLRMask() {
+        return AslrMask(38);
+      }
+      constexpr ALWAYS_INLINE uintptr_t ASLROffset() {
+        return AslrAddress(0x1000000000ULL);
+      }
 
       #endif
 
@@ -107,20 +140,32 @@
         // 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 uintptr_t kASLRMask = AslrMask(30);
-        constexpr uintptr_t kASLROffset = AslrAddress(0x400000000000ULL);
+        constexpr ALWAYS_INLINE uintptr_t ASLRMask() {
+          return AslrMask(30);
+        }
+        constexpr 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 uintptr_t kASLRMask = AslrMask(42);
-        constexpr uintptr_t kASLROffset = AslrAddress(0);
+        constexpr ALWAYS_INLINE uintptr_t ASLRMask() {
+          return AslrMask(42);
+        }
+        constexpr ALWAYS_INLINE uintptr_t ASLROffset() {
+          return AslrAddress(0);
+        }
 
       #else  // !defined(OS_AIX) && !defined(ARCH_CPU_BIG_ENDIAN)
 
         // Little-endian Linux PPC has 48 bits of virtual addressing. Use 46.
-        constexpr uintptr_t kASLRMask = AslrMask(46);
-        constexpr uintptr_t kASLROffset = AslrAddress(0);
+        constexpr ALWAYS_INLINE uintptr_t ASLRMask() {
+          return AslrMask(46);
+        }
+        constexpr ALWAYS_INLINE uintptr_t ASLROffset() {
+          return AslrAddress(0);
+        }
 
       #endif  // !defined(OS_AIX) && !defined(ARCH_CPU_BIG_ENDIAN)
 
@@ -129,21 +174,31 @@
       // 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 uintptr_t kASLRMask = AslrMask(40);
-      constexpr uintptr_t kASLROffset = AslrAddress(0);
+      constexpr ALWAYS_INLINE uintptr_t ASLRMask() {
+        return AslrMask(40);
+      }
+      constexpr 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 uintptr_t kASLRMask = AslrMask(29);
-      constexpr uintptr_t kASLROffset = AslrAddress(0);
+      constexpr ALWAYS_INLINE uintptr_t ASLRMask() {
+        return AslrMask(29);
+      }
+      constexpr 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 uintptr_t kASLRMask = AslrMask(30);
+      constexpr ALWAYS_INLINE uintptr_t ASLRMask() {
+        return AslrMask(30);
+      }
 
       #if defined(OS_SOLARIS)
 
@@ -157,20 +212,26 @@
         // 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 uintptr_t kASLROffset = AslrAddress(0x80000000ULL);
+        constexpr ALWAYS_INLINE uintptr_t ASLROffset() {
+          return AslrAddress(0x80000000ULL);
+        }
 
       #elif defined(OS_AIX)
 
         // The range 0x30000000 - 0xD0000000 is available on AIX; choose the
         // upper range.
-        constexpr uintptr_t kASLROffset = AslrAddress(0x90000000ULL);
+        constexpr ALWAYS_INLINE uintptr_t ASLROffset() {
+          return AslrAddress(0x90000000ULL);
+        }
 
       #else  // !defined(OS_SOLARIS) && !defined(OS_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 uintptr_t kASLROffset = AslrAddress(0x20000000ULL);
+        constexpr ALWAYS_INLINE uintptr_t ASLROffset() {
+          return AslrAddress(0x20000000ULL);
+        }
 
       #endif  // !defined(OS_SOLARIS) && !defined(OS_AIX)
 
@@ -184,8 +245,12 @@
   // 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 uintptr_t kASLRMask = AslrMask(30);
-  constexpr uintptr_t kASLROffset = AslrAddress(0x20000000ULL);
+  constexpr ALWAYS_INLINE uintptr_t ASLRMask() {
+    return AslrMask(30);
+  }
+  constexpr ALWAYS_INLINE uintptr_t ASLROffset() {
+    return AslrAddress(0x20000000ULL);
+  }
 
 #else
 
diff --git a/third_party/base/allocator/partition_allocator/page_allocator.cc b/third_party/base/allocator/partition_allocator/page_allocator.cc
index e158bd1..91d00d2 100644
--- a/third_party/base/allocator/partition_allocator/page_allocator.cc
+++ b/third_party/base/allocator/partition_allocator/page_allocator.cc
@@ -92,9 +92,9 @@
                        PageAccessibilityConfiguration accessibility,
                        PageTag page_tag,
                        bool commit) {
-  DCHECK(!(length & kPageAllocationGranularityOffsetMask));
+  DCHECK(!(length & PageAllocationGranularityOffsetMask()));
   DCHECK(!(reinterpret_cast<uintptr_t>(hint) &
-           kPageAllocationGranularityOffsetMask));
+           PageAllocationGranularityOffsetMask()));
   DCHECK(commit || accessibility == PageInaccessible);
   return SystemAllocPagesInternal(hint, length, accessibility, page_tag,
                                   commit);
@@ -106,13 +106,13 @@
                  PageAccessibilityConfiguration accessibility,
                  PageTag page_tag,
                  bool commit) {
-  DCHECK(length >= kPageAllocationGranularity);
-  DCHECK(!(length & kPageAllocationGranularityOffsetMask));
-  DCHECK(align >= kPageAllocationGranularity);
+  DCHECK(length >= PageAllocationGranularity());
+  DCHECK(!(length & PageAllocationGranularityOffsetMask()));
+  DCHECK(align >= PageAllocationGranularity());
   // Alignment must be power of 2 for masking math to work.
   DCHECK(pdfium::base::bits::IsPowerOfTwo(align));
   DCHECK(!(reinterpret_cast<uintptr_t>(address) &
-           kPageAllocationGranularityOffsetMask));
+           PageAllocationGranularityOffsetMask()));
   uintptr_t align_offset_mask = align - 1;
   uintptr_t align_base_mask = ~align_offset_mask;
   DCHECK(!(reinterpret_cast<uintptr_t>(address) & align_offset_mask));
@@ -164,7 +164,7 @@
   }
 
   // Make a larger allocation so we can force alignment.
-  size_t try_length = length + (align - kPageAllocationGranularity);
+  size_t try_length = length + (align - PageAllocationGranularity());
   CHECK(try_length >= length);
   void* ret;
 
@@ -184,40 +184,40 @@
 
 void FreePages(void* address, size_t length) {
   DCHECK(!(reinterpret_cast<uintptr_t>(address) &
-           kPageAllocationGranularityOffsetMask));
-  DCHECK(!(length & kPageAllocationGranularityOffsetMask));
+           PageAllocationGranularityOffsetMask()));
+  DCHECK(!(length & PageAllocationGranularityOffsetMask()));
   FreePagesInternal(address, length);
 }
 
 bool TrySetSystemPagesAccess(void* address,
                              size_t length,
                              PageAccessibilityConfiguration accessibility) {
-  DCHECK(!(length & kSystemPageOffsetMask));
+  DCHECK(!(length & SystemPageOffsetMask()));
   return TrySetSystemPagesAccessInternal(address, length, accessibility);
 }
 
 void SetSystemPagesAccess(void* address,
                           size_t length,
                           PageAccessibilityConfiguration accessibility) {
-  DCHECK(!(length & kSystemPageOffsetMask));
+  DCHECK(!(length & SystemPageOffsetMask()));
   SetSystemPagesAccessInternal(address, length, accessibility);
 }
 
 void DecommitSystemPages(void* address, size_t length) {
-  DCHECK_EQ(0UL, length & kSystemPageOffsetMask);
+  DCHECK_EQ(0UL, length & SystemPageOffsetMask());
   DecommitSystemPagesInternal(address, length);
 }
 
 bool RecommitSystemPages(void* address,
                          size_t length,
                          PageAccessibilityConfiguration accessibility) {
-  DCHECK_EQ(0UL, length & kSystemPageOffsetMask);
+  DCHECK_EQ(0UL, length & SystemPageOffsetMask());
   DCHECK(PageInaccessible != accessibility);
   return RecommitSystemPagesInternal(address, length, accessibility);
 }
 
 void DiscardSystemPages(void* address, size_t length) {
-  DCHECK_EQ(0UL, length & kSystemPageOffsetMask);
+  DCHECK_EQ(0UL, length & SystemPageOffsetMask());
   DiscardSystemPagesInternal(address, length);
 }
 
@@ -230,7 +230,7 @@
     if (mem != nullptr) {
       // We guarantee this alignment when reserving address space.
       DCHECK(!(reinterpret_cast<uintptr_t>(mem) &
-               kPageAllocationGranularityOffsetMask));
+               PageAllocationGranularityOffsetMask()));
       s_reservation_address = mem;
       s_reservation_size = size;
       return true;
diff --git a/third_party/base/allocator/partition_allocator/page_allocator.h b/third_party/base/allocator/partition_allocator/page_allocator.h
index c50b908..b2eb7f6 100644
--- a/third_party/base/allocator/partition_allocator/page_allocator.h
+++ b/third_party/base/allocator/partition_allocator/page_allocator.h
@@ -42,9 +42,9 @@
 //
 // The requested |address| is just a hint; the actual address returned may
 // differ. The returned address will be aligned at least to |align| bytes.
-// |length| is in bytes, and must be a multiple of |kPageAllocationGranularity|.
-// |align| is in bytes, and must be a power-of-two multiple of
-// |kPageAllocationGranularity|.
+// |length| is in bytes, and must be a multiple of
+// |PageAllocationGranularity()|. |align| is in bytes, and must be a
+// power-of-two multiple of |PageAllocationGranularity()|.
 //
 // If |address| is null, then a suitable and randomized address will be chosen
 // automatically.
@@ -65,12 +65,13 @@
 // bytes.
 //
 // |address| and |length| must match a previous call to |AllocPages|. Therefore,
-// |address| must be aligned to |kPageAllocationGranularity| bytes, and |length|
-// must be a multiple of |kPageAllocationGranularity|.
+// |address| must be aligned to |PageAllocationGranularity()| bytes, and
+// |length| must be a multiple of |PageAllocationGranularity()|.
 BASE_EXPORT void FreePages(void* address, size_t length);
 
 // Mark one or more system pages, starting at |address| with the given
-// |page_accessibility|. |length| must be a multiple of |kSystemPageSize| bytes.
+// |page_accessibility|. |length| must be a multiple of |SystemPageSize()|
+// bytes.
 //
 // Returns true if the permission change succeeded. In most cases you must
 // |CHECK| the result.
@@ -80,7 +81,8 @@
     PageAccessibilityConfiguration page_accessibility);
 
 // Mark one or more system pages, starting at |address| with the given
-// |page_accessibility|. |length| must be a multiple of |kSystemPageSize| bytes.
+// |page_accessibility|. |length| must be a multiple of |SystemPageSize()|
+// bytes.
 //
 // Performs a CHECK that the operation succeeds.
 BASE_EXPORT void SetSystemPagesAccess(
@@ -89,7 +91,7 @@
     PageAccessibilityConfiguration page_accessibility);
 
 // Decommit one or more system pages starting at |address| and continuing for
-// |length| bytes. |length| must be a multiple of |kSystemPageSize|.
+// |length| bytes. |length| must be a multiple of |SystemPageSize()|.
 //
 // Decommitted means that physical resources (RAM or swap) backing the allocated
 // virtual address range are released back to the system, but the address space
@@ -113,7 +115,7 @@
 
 // Recommit one or more system pages, starting at |address| and continuing for
 // |length| bytes with the given |page_accessibility|. |length| must be a
-// multiple of |kSystemPageSize|.
+// multiple of |SystemPageSize()|.
 //
 // Decommitted system pages must be recommitted with their original permissions
 // before they are used again.
@@ -126,7 +128,7 @@
     PageAccessibilityConfiguration page_accessibility);
 
 // Discard one or more system pages starting at |address| and continuing for
-// |length| bytes. |length| must be a multiple of |kSystemPageSize|.
+// |length| bytes. |length| must be a multiple of |SystemPageSize()|.
 //
 // Discarding is a hint to the system that the page is no longer required. The
 // hint may:
@@ -148,35 +150,37 @@
 // based on the original page content, or a page of zeroes.
 BASE_EXPORT void DiscardSystemPages(void* address, size_t length);
 
-// Rounds up |address| to the next multiple of |kSystemPageSize|. Returns
+// Rounds up |address| to the next multiple of |SystemPageSize()|. Returns
 // 0 for an |address| of 0.
-constexpr ALWAYS_INLINE uintptr_t RoundUpToSystemPage(uintptr_t address) {
-  return (address + kSystemPageOffsetMask) & kSystemPageBaseMask;
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE uintptr_t
+RoundUpToSystemPage(uintptr_t address) {
+  return (address + SystemPageOffsetMask()) & SystemPageBaseMask();
 }
 
-// Rounds down |address| to the previous multiple of |kSystemPageSize|. Returns
+// Rounds down |address| to the previous multiple of |SystemPageSize()|. Returns
 // 0 for an |address| of 0.
-constexpr ALWAYS_INLINE uintptr_t RoundDownToSystemPage(uintptr_t address) {
-  return address & kSystemPageBaseMask;
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE uintptr_t
+RoundDownToSystemPage(uintptr_t address) {
+  return address & SystemPageBaseMask();
 }
 
-// Rounds up |address| to the next multiple of |kPageAllocationGranularity|.
+// Rounds up |address| to the next multiple of |PageAllocationGranularity()|.
 // Returns 0 for an |address| of 0.
-constexpr ALWAYS_INLINE uintptr_t
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE uintptr_t
 RoundUpToPageAllocationGranularity(uintptr_t address) {
-  return (address + kPageAllocationGranularityOffsetMask) &
-         kPageAllocationGranularityBaseMask;
+  return (address + PageAllocationGranularityOffsetMask()) &
+         PageAllocationGranularityBaseMask();
 }
 
 // Rounds down |address| to the previous multiple of
-// |kPageAllocationGranularity|. Returns 0 for an |address| of 0.
-constexpr ALWAYS_INLINE uintptr_t
+// |PageAllocationGranularity()|. Returns 0 for an |address| of 0.
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE uintptr_t
 RoundDownToPageAllocationGranularity(uintptr_t address) {
-  return address & kPageAllocationGranularityBaseMask;
+  return address & PageAllocationGranularityBaseMask();
 }
 
 // Reserves (at least) |size| bytes of address space, aligned to
-// |kPageAllocationGranularity|. This can be called early on to make it more
+// |PageAllocationGranularity()|. This can be called early on to make it more
 // likely that large allocations will succeed. Returns true if the reservation
 // succeeded, false if the reservation failed or a reservation was already made.
 BASE_EXPORT bool ReserveAddressSpace(size_t size);
diff --git a/third_party/base/allocator/partition_allocator/page_allocator_constants.h b/third_party/base/allocator/partition_allocator/page_allocator_constants.h
index 77c065a..fdc65ac 100644
--- a/third_party/base/allocator/partition_allocator/page_allocator_constants.h
+++ b/third_party/base/allocator/partition_allocator/page_allocator_constants.h
@@ -8,46 +8,109 @@
 #include <stddef.h>
 
 #include "build/build_config.h"
+#include "third_party/base/compiler_specific.h"
+
+#if defined(OS_APPLE)
+
+#include <mach/vm_page_size.h>
+
+// Although page allocator constants are not constexpr, they are run-time
+// constant. Because the underlying variables they access, such as vm_page_size,
+// are not marked const, the compiler normally has no way to know that they
+// don’t change and must obtain their values whenever it can't prove that they
+// haven't been modified, even if they had already been obtained previously.
+// Attaching __attribute__((const)) to these declarations allows these redundant
+// accesses to be omitted under optimization such as common subexpression
+// elimination.
+#define PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR __attribute__((const))
+
+#else
+
+// When defined, page size constants are fixed at compile time. When not
+// defined, they may vary at run time.
+#define PAGE_ALLOCATOR_CONSTANTS_ARE_CONSTEXPR 1
+
+// Use this macro to declare a function as constexpr or not based on whether
+// PAGE_ALLOCATOR_CONSTANTS_ARE_CONSTEXPR is defined.
+#define PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR constexpr
+
+#endif
 
 namespace pdfium {
-namespace base {
-#if defined(OS_WIN) || defined(ARCH_CPU_PPC64)
-static constexpr size_t kPageAllocationGranularityShift = 16;  // 64KB
-#elif defined(_MIPS_ARCH_LOONGSON)
-static constexpr size_t kPageAllocationGranularityShift = 14;  // 16KB
-#elif defined(OS_APPLE) && defined(ARCH_CPU_ARM64)
-static constexpr size_t kPageAllocationGranularityShift = 14;  // 16KB
-#else
-static constexpr size_t kPageAllocationGranularityShift = 12;  // 4KB
-#endif
-static constexpr size_t kPageAllocationGranularity =
-    1 << kPageAllocationGranularityShift;
-static constexpr size_t kPageAllocationGranularityOffsetMask =
-    kPageAllocationGranularity - 1;
-static constexpr size_t kPageAllocationGranularityBaseMask =
-    ~kPageAllocationGranularityOffsetMask;
+namespace {
 
-#if defined(_MIPS_ARCH_LOONGSON)
-static constexpr size_t kSystemPageSize = 16384;
-#elif defined(ARCH_CPU_PPC64)
-// Modern ppc64 systems support 4KB and 64KB page sizes.
-// Since 64KB is the de-facto standard on the platform
-// and binaries compiled for 64KB are likely to work on 4KB systems,
-// 64KB is a good choice here.
-static constexpr size_t kSystemPageSize = 65536;
-#elif defined(OS_APPLE) && defined(ARCH_CPU_ARM64)
-static constexpr size_t kSystemPageSize = 16384;
+#if !defined(OS_APPLE)
+
+constexpr ALWAYS_INLINE int PageAllocationGranularityShift() {
+#if defined(OS_WIN) || defined(ARCH_CPU_PPC64)
+  // Modern ppc64 systems support 4kB (shift = 12) and 64kB (shift = 16) page
+  // sizes.  Since 64kB is the de facto standard on the platform and binaries
+  // compiled for 64kB are likely to work on 4kB systems, 64kB is a good choice
+  // here.
+  return 16;  // 64kB
+#elif defined(_MIPS_ARCH_LOONGSON)
+  return 14;  // 16kB
 #else
-static constexpr size_t kSystemPageSize = 4096;
+  return 12;  // 4kB
 #endif
-static constexpr size_t kSystemPageOffsetMask = kSystemPageSize - 1;
-static_assert((kSystemPageSize & (kSystemPageSize - 1)) == 0,
-              "kSystemPageSize must be power of 2");
-static constexpr size_t kSystemPageBaseMask = ~kSystemPageOffsetMask;
+}
+
+#endif
+
+}  // namespace
+
+namespace base {
+
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+PageAllocationGranularity() {
+#if defined(OS_APPLE)
+  return vm_page_size;
+#else
+  return 1ULL << PageAllocationGranularityShift();
+#endif
+}
+
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+PageAllocationGranularityOffsetMask() {
+  return PageAllocationGranularity() - 1;
+}
+
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+PageAllocationGranularityBaseMask() {
+  return ~PageAllocationGranularityOffsetMask();
+}
+
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+SystemPageSize() {
+#if defined(OS_WIN)
+  return 4096;
+#else
+  return PageAllocationGranularity();
+#endif
+}
+
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+SystemPageOffsetMask() {
+  return SystemPageSize() - 1;
+}
+
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+SystemPageBaseMask() {
+  return ~SystemPageOffsetMask();
+}
 
 static constexpr size_t kPageMetadataShift = 5;  // 32 bytes per partition page.
 static constexpr size_t kPageMetadataSize = 1 << kPageMetadataShift;
 
+// See DecommitSystemPages(), this is not guaranteed to be synchronous on all
+// platforms.
+static constexpr bool kDecommittedPagesAreAlwaysZeroed =
+#if defined(OS_APPLE)
+    false;
+#else
+    true;
+#endif
+
 }  // namespace base
 }  // namespace pdfium
 
diff --git a/third_party/base/allocator/partition_allocator/partition_alloc.cc b/third_party/base/allocator/partition_allocator/partition_alloc.cc
index 910891b..2e5e87f 100644
--- a/third_party/base/allocator/partition_allocator/partition_alloc.cc
+++ b/third_party/base/allocator/partition_allocator/partition_alloc.cc
@@ -9,6 +9,7 @@
 #include <memory>
 #include <type_traits>
 
+#include "third_party/base/allocator/partition_allocator/partition_alloc_check.h"
 #include "third_party/base/allocator/partition_allocator/partition_direct_map_extent.h"
 #include "third_party/base/allocator/partition_allocator/partition_oom.h"
 #include "third_party/base/allocator/partition_allocator/partition_page.h"
@@ -29,36 +30,6 @@
 
 }  // namespace
 
-// Two partition pages are used as guard / metadata page so make sure the super
-// page size is bigger.
-static_assert(kPartitionPageSize * 4 <= kSuperPageSize, "ok super page size");
-static_assert(!(kSuperPageSize % kPartitionPageSize), "ok super page multiple");
-// Four system pages gives us room to hack out a still-guard-paged piece
-// of metadata in the middle of a guard partition page.
-static_assert(kSystemPageSize * 4 <= kPartitionPageSize,
-              "ok partition page size");
-static_assert(!(kPartitionPageSize % kSystemPageSize),
-              "ok partition page multiple");
-static_assert(sizeof(internal::PartitionPage) <= kPageMetadataSize,
-              "PartitionPage should not be too big");
-static_assert(sizeof(internal::PartitionBucket) <= kPageMetadataSize,
-              "PartitionBucket should not be too big");
-static_assert(sizeof(internal::PartitionSuperPageExtentEntry) <=
-                  kPageMetadataSize,
-              "PartitionSuperPageExtentEntry should not be too big");
-static_assert(kPageMetadataSize * kNumPartitionPagesPerSuperPage <=
-                  kSystemPageSize,
-              "page metadata fits in hole");
-// Limit to prevent callers accidentally overflowing an int size.
-static_assert(kGenericMaxDirectMapped <=
-                  (1UL << 31) + kPageAllocationGranularity,
-              "maximum direct mapped allocation");
-// Check that some of our zanier calculations worked out as expected.
-static_assert(kGenericSmallestBucket == 8, "generic smallest bucket");
-static_assert(kGenericMaxBucketed == 983040, "generic max bucketed");
-static_assert(kMaxSystemPagesPerSlotSpan < (1 << 8),
-              "System pages per slot span must be less than 128.");
-
 internal::PartitionRootBase::PartitionRootBase() = default;
 internal::PartitionRootBase::~PartitionRootBase() = default;
 PartitionRoot::PartitionRoot() = default;
@@ -190,6 +161,38 @@
 }
 
 void PartitionAllocGlobalInit(OomFunction on_out_of_memory) {
+  // Two partition pages are used as guard / metadata page so make sure the
+  // super page size is bigger.
+  STATIC_ASSERT_OR_CHECK(PartitionPageSize() * 4 <= kSuperPageSize,
+                         "ok super page size");
+  STATIC_ASSERT_OR_CHECK(!(kSuperPageSize % PartitionPageSize()),
+                         "ok super page multiple");
+  // Four system pages gives us room to hack out a still-guard-paged piece
+  // of metadata in the middle of a guard partition page.
+  STATIC_ASSERT_OR_CHECK(SystemPageSize() * 4 <= PartitionPageSize(),
+                         "ok partition page size");
+  STATIC_ASSERT_OR_CHECK(!(PartitionPageSize() % SystemPageSize()),
+                         "ok partition page multiple");
+  static_assert(sizeof(internal::PartitionPage) <= kPageMetadataSize,
+                "PartitionPage should not be too big");
+  static_assert(sizeof(internal::PartitionBucket) <= kPageMetadataSize,
+                "PartitionBucket should not be too big");
+  static_assert(
+      sizeof(internal::PartitionSuperPageExtentEntry) <= kPageMetadataSize,
+      "PartitionSuperPageExtentEntry should not be too big");
+  STATIC_ASSERT_OR_CHECK(
+      kPageMetadataSize * NumPartitionPagesPerSuperPage() <= SystemPageSize(),
+      "page metadata fits in hole");
+  // Limit to prevent callers accidentally overflowing an int size.
+  STATIC_ASSERT_OR_CHECK(
+      GenericMaxDirectMapped() <= (1UL << 31) + PageAllocationGranularity(),
+      "maximum direct mapped allocation");
+  // Check that some of our zanier calculations worked out as expected.
+  static_assert(kGenericSmallestBucket == 8, "generic smallest bucket");
+  static_assert(kGenericMaxBucketed == 983040, "generic max bucketed");
+  STATIC_ASSERT_OR_CHECK(MaxSystemPagesPerSlotSpan() < (1 << 8),
+                         "System pages per slot span must be less than 128.");
+
   DCHECK(on_out_of_memory);
   internal::PartitionRootBase::g_oom_handling_function = on_out_of_memory;
 }
@@ -314,7 +317,7 @@
 
     // Don't reallocate in-place if new size is less than 80 % of the full
     // map size, to avoid holding on to too much unused address space.
-    if ((new_size / kSystemPageSize) * 5 < (map_size / kSystemPageSize) * 4)
+    if ((new_size / SystemPageSize()) * 5 < (map_size / SystemPageSize()) * 4)
       return false;
 
     // Shrink by decommitting unneeded pages and making them inaccessible.
@@ -369,7 +372,7 @@
     return nullptr;
   }
 
-  if (new_size > kGenericMaxDirectMapped) {
+  if (new_size > GenericMaxDirectMapped()) {
     if (flags & PartitionAllocReturnNull)
       return nullptr;
     internal::PartitionExcessiveAllocationSize(new_size);
@@ -461,7 +464,7 @@
 static size_t PartitionPurgePage(internal::PartitionPage* page, bool discard) {
   const internal::PartitionBucket* bucket = page->bucket;
   size_t slot_size = bucket->slot_size;
-  if (slot_size < kSystemPageSize || !page->num_allocated_slots)
+  if (slot_size < SystemPageSize() || !page->num_allocated_slots)
     return 0;
 
   size_t bucket_num_slots = bucket->get_slots_per_span();
@@ -480,8 +483,18 @@
     return discardable_bytes;
   }
 
+#if defined(PAGE_ALLOCATOR_CONSTANTS_ARE_CONSTEXPR)
   constexpr size_t kMaxSlotCount =
-      (kPartitionPageSize * kMaxPartitionPagesPerSlotSpan) / kSystemPageSize;
+      (PartitionPageSize() * kMaxPartitionPagesPerSlotSpan) / SystemPageSize();
+#elif defined(OS_APPLE)
+  // It's better for slot_usage to be stack-allocated and fixed-size, which
+  // demands that its size be constexpr. On OS_APPLE, PartitionPageSize() is
+  // always SystemPageSize() << 2, so regardless of what the run time page size
+  // is, kMaxSlotCount can always be simplified to this expression.
+  constexpr size_t kMaxSlotCount = 4 * kMaxPartitionPagesPerSlotSpan;
+  CHECK(kMaxSlotCount == (PartitionPageSize() * kMaxPartitionPagesPerSlotSpan) /
+                             SystemPageSize());
+#endif
   DCHECK(bucket_num_slots <= kMaxSlotCount);
   DCHECK(page->num_unprovisioned_slots < bucket_num_slots);
   size_t num_slots = bucket_num_slots - page->num_unprovisioned_slots;
@@ -632,7 +645,7 @@
   if (flags & PartitionPurgeDiscardUnusedSystemPages) {
     for (size_t i = 0; i < kGenericNumBuckets; ++i) {
       internal::PartitionBucket* bucket = &buckets[i];
-      if (bucket->slot_size >= kSystemPageSize)
+      if (bucket->slot_size >= SystemPageSize())
         PartitionPurgeBucket(bucket);
     }
   }
diff --git a/third_party/base/allocator/partition_allocator/partition_alloc.h b/third_party/base/allocator/partition_allocator/partition_alloc.h
index 2dc62b6..084a2a2 100644
--- a/third_party/base/allocator/partition_allocator/partition_alloc.h
+++ b/third_party/base/allocator/partition_allocator/partition_alloc.h
@@ -85,7 +85,7 @@
 // We use this to make MEMORY_TOOL_REPLACES_ALLOCATOR behave the same for max
 // size as other alloc code.
 #define CHECK_MAX_SIZE_OR_RETURN_NULLPTR(size, flags) \
-  if (size > kGenericMaxDirectMapped) {               \
+  if (size > GenericMaxDirectMapped()) {              \
     if (flags & PartitionAllocReturnNull) {           \
       return nullptr;                                 \
     }                                                 \
@@ -487,7 +487,7 @@
   internal::PartitionBucket* bucket = PartitionGenericSizeToBucket(this, size);
   if (LIKELY(!bucket->is_direct_mapped())) {
     size = bucket->slot_size;
-  } else if (size > kGenericMaxDirectMapped) {
+  } else if (size > GenericMaxDirectMapped()) {
     // Too large to allocate => return the size unchanged.
   } else {
     size = internal::PartitionBucket::get_direct_map_size(size);
diff --git a/third_party/base/allocator/partition_allocator/partition_alloc_check.h b/third_party/base/allocator/partition_allocator/partition_alloc_check.h
new file mode 100644
index 0000000..51c23e2
--- /dev/null
+++ b/third_party/base/allocator/partition_allocator/partition_alloc_check.h
@@ -0,0 +1,32 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef THIRD_PARTY_BASE_ALLOCATOR_PARTITION_ALLOCATOR_PARTITION_ALLOC_CHECK_H_
+#define THIRD_PARTY_BASE_ALLOCATOR_PARTITION_ALLOCATOR_PARTITION_ALLOC_CHECK_H_
+
+#include "third_party/base/allocator/partition_allocator/page_allocator_constants.h"
+#include "third_party/base/logging.h"
+
+#if defined(PAGE_ALLOCATOR_CONSTANTS_ARE_CONSTEXPR)
+
+// Use this macro to assert on things that are conditionally constexpr as
+// determined by PAGE_ALLOCATOR_CONSTANTS_ARE_CONSTEXPR or
+// PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR. Where fixed at compile time, this
+// is a static_assert. Where determined at run time, this is a CHECK.
+// Therefore, this macro must only be used where both a static_assert and a
+// CHECK would be viable, that is, within a function, and ideally a function
+// that executes only once, early in the program, such as during initialization.
+#define STATIC_ASSERT_OR_CHECK(condition, message) \
+  static_assert(condition, message)
+
+#else
+
+#define STATIC_ASSERT_OR_CHECK(condition, message) \
+  do {                                             \
+    CHECK(condition);                              \
+  } while (false)
+
+#endif
+
+#endif  // THIRD_PARTY_BASE_ALLOCATOR_PARTITION_ALLOCATOR_PARTITION_ALLOC_CHECK_H_
diff --git a/third_party/base/allocator/partition_allocator/partition_alloc_constants.h b/third_party/base/allocator/partition_allocator/partition_alloc_constants.h
index ef39b41..71d63ba 100644
--- a/third_party/base/allocator/partition_allocator/partition_alloc_constants.h
+++ b/third_party/base/allocator/partition_allocator/partition_alloc_constants.h
@@ -6,11 +6,16 @@
 #define THIRD_PARTY_BASE_ALLOCATOR_PARTITION_ALLOCATOR_PARTITION_ALLOC_CONSTANTS_H_
 
 #include <limits.h>
+#include <stddef.h>
 
 #include "build/build_config.h"
 #include "third_party/base/allocator/partition_allocator/page_allocator_constants.h"
 #include "third_party/base/logging.h"
 
+#if defined(OS_APPLE)
+#include <mach/vm_page_size.h>
+#endif
+
 namespace pdfium {
 namespace base {
 
@@ -36,17 +41,38 @@
 // perfectly up against the end of a system page.
 
 #if defined(_MIPS_ARCH_LOONGSON)
-static const size_t kPartitionPageShift = 16;  // 64 KiB
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE int
+PartitionPageShift() {
+  return 16;  // 64 KiB
+}
 #elif defined(ARCH_CPU_PPC64)
-static const size_t kPartitionPageShift = 18;  // 256 KiB
-#elif defined(OS_APPLE) && defined(ARCH_CPU_ARM64)
-static const size_t kPartitionPageShift = 16;  // 64 KiB
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE int
+PartitionPageShift() {
+  return 18;  // 256 KiB
+}
+#elif defined(OS_APPLE)
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE int
+PartitionPageShift() {
+  return vm_page_shift + 2;
+}
 #else
-static const size_t kPartitionPageShift = 14;  // 16 KiB
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE int
+PartitionPageShift() {
+  return 14;  // 16 KiB
+}
 #endif
-static const size_t kPartitionPageSize = 1 << kPartitionPageShift;
-static const size_t kPartitionPageOffsetMask = kPartitionPageSize - 1;
-static const size_t kPartitionPageBaseMask = ~kPartitionPageOffsetMask;
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+PartitionPageSize() {
+  return 1ULL << PartitionPageShift();
+}
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+PartitionPageOffsetMask() {
+  return PartitionPageSize() - 1;
+}
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+PartitionPageBaseMask() {
+  return ~PartitionPageOffsetMask();
+}
 // TODO: Should this be 1 if defined(_MIPS_ARCH_LOONGSON)?
 static const size_t kMaxPartitionPagesPerSlotSpan = 4;
 
@@ -57,10 +83,15 @@
 // dirty a private page, which is very wasteful if we never actually store
 // objects there.
 
-static const size_t kNumSystemPagesPerPartitionPage =
-    kPartitionPageSize / kSystemPageSize;
-static const size_t kMaxSystemPagesPerSlotSpan =
-    kNumSystemPagesPerPartitionPage * kMaxPartitionPagesPerSlotSpan;
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+NumSystemPagesPerPartitionPage() {
+  return PartitionPageSize() / SystemPageSize();
+}
+
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+MaxSystemPagesPerSlotSpan() {
+  return NumSystemPagesPerPartitionPage() * kMaxPartitionPagesPerSlotSpan;
+}
 
 // We reserve virtual address space in 2 MiB chunks (aligned to 2 MiB as well).
 // These chunks are called *super pages*. We do this so that we can store
@@ -126,8 +157,10 @@
 static const size_t kSuperPageSize = 1 << kSuperPageShift;
 static const size_t kSuperPageOffsetMask = kSuperPageSize - 1;
 static const size_t kSuperPageBaseMask = ~kSuperPageOffsetMask;
-static const size_t kNumPartitionPagesPerSuperPage =
-    kSuperPageSize / kPartitionPageSize;
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+NumPartitionPagesPerSuperPage() {
+  return kSuperPageSize / PartitionPageSize();
+}
 
 // The following kGeneric* constants apply to the generic variants of the API.
 // The "order" of an allocation is closely related to the power-of-1 size of the
@@ -159,8 +192,10 @@
     ((kGenericNumBucketsPerOrder - 1) * kGenericMaxBucketSpacing);
 // Limit when downsizing a direct mapping using `realloc`:
 static const size_t kGenericMinDirectMappedDownsize = kGenericMaxBucketed + 1;
-static const size_t kGenericMaxDirectMapped =
-    (1UL << 31) + kPageAllocationGranularity;  // 2 GiB plus 1 more page.
+PAGE_ALLOCATOR_CONSTANTS_DECLARE_CONSTEXPR ALWAYS_INLINE size_t
+GenericMaxDirectMapped() {
+  return (1UL << 31) + PageAllocationGranularity();  // 2 GiB plus 1 more page.
+}
 static const size_t kBitsPerSizeT = sizeof(void*) * CHAR_BIT;
 
 // Constant for the memory reclaim logic.
diff --git a/third_party/base/allocator/partition_allocator/partition_bucket.cc b/third_party/base/allocator/partition_allocator/partition_bucket.cc
index 066f40c..4a02d4b 100644
--- a/third_party/base/allocator/partition_allocator/partition_bucket.cc
+++ b/third_party/base/allocator/partition_allocator/partition_bucket.cc
@@ -31,13 +31,13 @@
   // page sized clump.
   // - We add a trailing guard page on 32-bit (on 64-bit we rely on the
   // massive address space plus randomization instead).
-  size_t map_size = size + kPartitionPageSize;
+  size_t map_size = size + PartitionPageSize();
 #if !defined(ARCH_CPU_64_BITS)
-  map_size += kSystemPageSize;
+  map_size += SystemPageSize();
 #endif
   // Round up to the allocation granularity.
-  map_size += kPageAllocationGranularityOffsetMask;
-  map_size &= kPageAllocationGranularityBaseMask;
+  map_size += PageAllocationGranularityOffsetMask();
+  map_size &= PageAllocationGranularityBaseMask();
 
   char* ptr = reinterpret_cast<char*>(AllocPages(nullptr, map_size,
                                                  kSuperPageSize, PageReadWrite,
@@ -45,17 +45,17 @@
   if (UNLIKELY(!ptr))
     return nullptr;
 
-  size_t committed_page_size = size + kSystemPageSize;
+  size_t committed_page_size = size + SystemPageSize();
   root->total_size_of_direct_mapped_pages += committed_page_size;
   root->IncreaseCommittedPages(committed_page_size);
 
-  char* slot = ptr + kPartitionPageSize;
-  SetSystemPagesAccess(ptr + (kSystemPageSize * 2),
-                       kPartitionPageSize - (kSystemPageSize * 2),
+  char* slot = ptr + PartitionPageSize();
+  SetSystemPagesAccess(ptr + (SystemPageSize() * 2),
+                       PartitionPageSize() - (SystemPageSize() * 2),
                        PageInaccessible);
 #if !defined(ARCH_CPU_64_BITS)
-  SetSystemPagesAccess(ptr, kSystemPageSize, PageInaccessible);
-  SetSystemPagesAccess(slot + size, kSystemPageSize, PageInaccessible);
+  SetSystemPagesAccess(ptr, SystemPageSize(), PageInaccessible);
+  SetSystemPagesAccess(slot + size, SystemPageSize(), PageInaccessible);
 #endif
 
   PartitionSuperPageExtentEntry* extent =
@@ -90,7 +90,7 @@
 
   PartitionDirectMapExtent* map_extent =
       PartitionDirectMapExtent::FromPage(page);
-  map_extent->map_size = map_size - kPartitionPageSize - kSystemPageSize;
+  map_extent->map_size = map_size - PartitionPageSize() - SystemPageSize();
   map_extent->bucket = bucket;
 
   // Maintain the doubly-linked list of all direct mappings.
@@ -114,7 +114,7 @@
 
 // TODO(ajwong): This seems to interact badly with
 // get_pages_per_slot_span() which rounds the value from this up to a
-// multiple of kNumSystemPagesPerPartitionPage (aka 4) anyways.
+// multiple of NumSystemPagesPerPartitionPage() (aka 4) anyways.
 // http://crbug.com/776537
 //
 // TODO(ajwong): The waste calculation seems wrong. The PTE usage should cover
@@ -133,21 +133,21 @@
   // to using fewer system pages.
   double best_waste_ratio = 1.0f;
   uint16_t best_pages = 0;
-  if (slot_size > kMaxSystemPagesPerSlotSpan * kSystemPageSize) {
+  if (slot_size > MaxSystemPagesPerSlotSpan() * SystemPageSize()) {
     // TODO(ajwong): Why is there a DCHECK here for this?
     // http://crbug.com/776537
-    DCHECK(!(slot_size % kSystemPageSize));
-    best_pages = static_cast<uint16_t>(slot_size / kSystemPageSize);
+    DCHECK(!(slot_size % SystemPageSize()));
+    best_pages = static_cast<uint16_t>(slot_size / SystemPageSize());
     // TODO(ajwong): Should this be checking against
-    // kMaxSystemPagesPerSlotSpan or numeric_limits<uint8_t>::max?
+    // MaxSystemPagesPerSlotSpan() or numeric_limits<uint8_t>::max?
     // http://crbug.com/776537
     CHECK(best_pages < (1 << 8));
     return static_cast<uint8_t>(best_pages);
   }
-  DCHECK(slot_size <= kMaxSystemPagesPerSlotSpan * kSystemPageSize);
-  for (uint16_t i = kNumSystemPagesPerPartitionPage - 1;
-       i <= kMaxSystemPagesPerSlotSpan; ++i) {
-    size_t page_size = kSystemPageSize * i;
+  DCHECK(slot_size <= MaxSystemPagesPerSlotSpan() * SystemPageSize());
+  for (uint16_t i = NumSystemPagesPerPartitionPage() - 1;
+       i <= MaxSystemPagesPerSlotSpan(); ++i) {
+    size_t page_size = SystemPageSize() * i;
     size_t num_slots = page_size / slot_size;
     size_t waste = page_size - (num_slots * slot_size);
     // Leaving a page unfaulted is not free; the page will occupy an empty page
@@ -157,10 +157,10 @@
     // regardless of whether or not they are wasted. Should it just
     // be waste += i * sizeof(void*)?
     // http://crbug.com/776537
-    size_t num_remainder_pages = i & (kNumSystemPagesPerPartitionPage - 1);
+    size_t num_remainder_pages = i & (NumSystemPagesPerPartitionPage() - 1);
     size_t num_unfaulted_pages =
         num_remainder_pages
-            ? (kNumSystemPagesPerPartitionPage - num_remainder_pages)
+            ? (NumSystemPagesPerPartitionPage() - num_remainder_pages)
             : 0;
     waste += sizeof(void*) * num_unfaulted_pages;
     double waste_ratio =
@@ -171,7 +171,7 @@
     }
   }
   DCHECK(best_pages > 0);
-  CHECK(best_pages <= kMaxSystemPagesPerSlotSpan);
+  CHECK(best_pages <= MaxSystemPagesPerSlotSpan());
   return static_cast<uint8_t>(best_pages);
 }
 
@@ -193,14 +193,14 @@
     int flags,
     uint16_t num_partition_pages) {
   DCHECK(!(reinterpret_cast<uintptr_t>(root->next_partition_page) %
-           kPartitionPageSize));
+           PartitionPageSize()));
   DCHECK(!(reinterpret_cast<uintptr_t>(root->next_partition_page_end) %
-           kPartitionPageSize));
-  DCHECK(num_partition_pages <= kNumPartitionPagesPerSuperPage);
-  size_t total_size = kPartitionPageSize * num_partition_pages;
+           PartitionPageSize()));
+  DCHECK(num_partition_pages <= NumPartitionPagesPerSuperPage());
+  size_t total_size = PartitionPageSize() * num_partition_pages;
   size_t num_partition_pages_left =
       (root->next_partition_page_end - root->next_partition_page) >>
-      kPartitionPageShift;
+      PartitionPageShift();
   if (LIKELY(num_partition_pages_left >= num_partition_pages)) {
     // In this case, we can still hand out pages from the current super page
     // allocation.
@@ -229,34 +229,33 @@
   root->total_size_of_super_pages += kSuperPageSize;
   root->IncreaseCommittedPages(total_size);
 
-  // |total_size| MUST be less than kSuperPageSize - (kPartitionPageSize*2).
+  // |total_size| MUST be less than kSuperPageSize - (PartitionPageSize()*2).
   // This is a trustworthy value because num_partition_pages is not user
   // controlled.
   //
   // TODO(ajwong): Introduce a DCHECK.
   root->next_super_page = super_page + kSuperPageSize;
-  char* ret = super_page + kPartitionPageSize;
+  char* ret = super_page + PartitionPageSize();
   root->next_partition_page = ret + total_size;
-  root->next_partition_page_end = root->next_super_page - kPartitionPageSize;
+  root->next_partition_page_end = root->next_super_page - PartitionPageSize();
   // Make the first partition page in the super page a guard page, but leave a
   // hole in the middle.
   // This is where we put page metadata and also a tiny amount of extent
   // metadata.
-  SetSystemPagesAccess(super_page, kSystemPageSize, PageInaccessible);
-  SetSystemPagesAccess(super_page + (kSystemPageSize * 2),
-                       kPartitionPageSize - (kSystemPageSize * 2),
+  SetSystemPagesAccess(super_page, SystemPageSize(), PageInaccessible);
+  SetSystemPagesAccess(super_page + (SystemPageSize() * 2),
+                       PartitionPageSize() - (SystemPageSize() * 2),
                        PageInaccessible);
   //  SetSystemPagesAccess(super_page + (kSuperPageSize -
-  //  kPartitionPageSize),
-  //                             kPartitionPageSize, PageInaccessible);
+  //  PartitionPageSize()), PartitionPageSize(), PageInaccessible);
   // All remaining slotspans for the unallocated PartitionPages inside the
   // SuperPage are conceptually decommitted. Correctly set the state here
   // so they do not occupy resources.
   //
   // TODO(ajwong): Refactor Page Allocator API so the SuperPage comes in
   // decommited initially.
-  SetSystemPagesAccess(super_page + kPartitionPageSize + total_size,
-                       (kSuperPageSize - kPartitionPageSize - total_size),
+  SetSystemPagesAccess(super_page + PartitionPageSize() + total_size,
+                       (kSuperPageSize - PartitionPageSize() - total_size),
                        PageInaccessible);
 
   // If we were after a specific address, but didn't get it, assume that
@@ -308,10 +307,10 @@
 }
 
 ALWAYS_INLINE uint16_t PartitionBucket::get_pages_per_slot_span() {
-  // Rounds up to nearest multiple of kNumSystemPagesPerPartitionPage.
+  // Rounds up to nearest multiple of NumSystemPagesPerPartitionPage().
   return (num_system_pages_per_slot_span +
-          (kNumSystemPagesPerPartitionPage - 1)) /
-         kNumSystemPagesPerPartitionPage;
+          (NumSystemPagesPerPartitionPage() - 1)) /
+         NumSystemPagesPerPartitionPage();
 }
 
 ALWAYS_INLINE void PartitionBucket::InitializeSlotSpan(PartitionPage* page) {
@@ -475,7 +474,7 @@
     DCHECK(size > kGenericMaxBucketed);
     DCHECK(this == get_sentinel_bucket());
     DCHECK(active_pages_head == PartitionPage::get_sentinel_page());
-    if (size > kGenericMaxDirectMapped) {
+    if (size > GenericMaxDirectMapped()) {
       if (return_null)
         return nullptr;
       PartitionExcessiveAllocationSize(size);
diff --git a/third_party/base/allocator/partition_allocator/partition_bucket.h b/third_party/base/allocator/partition_allocator/partition_bucket.h
index a89099b..f70a7da 100644
--- a/third_party/base/allocator/partition_allocator/partition_bucket.h
+++ b/third_party/base/allocator/partition_allocator/partition_bucket.h
@@ -50,7 +50,7 @@
   ALWAYS_INLINE size_t get_bytes_per_span() const {
     // TODO(ajwong): Change to CheckedMul. https://crbug.com/787153
     // https://crbug.com/680657
-    return num_system_pages_per_slot_span * kSystemPageSize;
+    return num_system_pages_per_slot_span * SystemPageSize();
   }
   ALWAYS_INLINE uint16_t get_slots_per_span() const {
     // TODO(ajwong): Change to CheckedMul. https://crbug.com/787153
@@ -59,11 +59,11 @@
   }
 
   static ALWAYS_INLINE size_t get_direct_map_size(size_t size) {
-    // Caller must check that the size is not above the kGenericMaxDirectMapped
+    // Caller must check that the size is not above the GenericMaxDirectMapped()
     // limit before calling. This also guards against integer overflow in the
     // calculation here.
-    DCHECK(size <= kGenericMaxDirectMapped);
-    return (size + kSystemPageOffsetMask) & kSystemPageBaseMask;
+    DCHECK(size <= GenericMaxDirectMapped());
+    return (size + SystemPageOffsetMask()) & SystemPageBaseMask();
   }
 
   // TODO(ajwong): Can this be made private?  https://crbug.com/787153
diff --git a/third_party/base/allocator/partition_allocator/partition_page.cc b/third_party/base/allocator/partition_allocator/partition_page.cc
index 0ddfe12..312c33b 100644
--- a/third_party/base/allocator/partition_allocator/partition_page.cc
+++ b/third_party/base/allocator/partition_allocator/partition_page.cc
@@ -33,19 +33,19 @@
 
   // Add on the size of the trailing guard page and preceeding partition
   // page.
-  unmap_size += kPartitionPageSize + kSystemPageSize;
+  unmap_size += PartitionPageSize() + SystemPageSize();
 
-  size_t uncommitted_page_size = page->bucket->slot_size + kSystemPageSize;
+  size_t uncommitted_page_size = page->bucket->slot_size + SystemPageSize();
   root->DecreaseCommittedPages(uncommitted_page_size);
   DCHECK(root->total_size_of_direct_mapped_pages >= uncommitted_page_size);
   root->total_size_of_direct_mapped_pages -= uncommitted_page_size;
 
-  DCHECK(!(unmap_size & kPageAllocationGranularityOffsetMask));
+  DCHECK(!(unmap_size & PageAllocationGranularityOffsetMask()));
 
   char* ptr = reinterpret_cast<char*>(PartitionPage::ToPointer(page));
   // Account for the mapping starting a partition page before the actual
   // allocation address.
-  ptr -= kPartitionPageSize;
+  ptr -= PartitionPageSize();
   return {ptr, unmap_size};
 }
 
diff --git a/third_party/base/allocator/partition_allocator/partition_page.h b/third_party/base/allocator/partition_allocator/partition_page.h
index 049ff26..9eb136b 100644
--- a/third_party/base/allocator/partition_allocator/partition_page.h
+++ b/third_party/base/allocator/partition_allocator/partition_page.h
@@ -136,7 +136,7 @@
   DCHECK(!(pointer_as_uint & kSuperPageOffsetMask));
   // The metadata area is exactly one system page (the guard page) into the
   // super page.
-  return reinterpret_cast<char*>(pointer_as_uint + kSystemPageSize);
+  return reinterpret_cast<char*>(pointer_as_uint + SystemPageSize());
 }
 
 ALWAYS_INLINE PartitionPage* PartitionPage::FromPointerNoAlignmentCheck(
@@ -145,11 +145,11 @@
   char* super_page_ptr =
       reinterpret_cast<char*>(pointer_as_uint & kSuperPageBaseMask);
   uintptr_t partition_page_index =
-      (pointer_as_uint & kSuperPageOffsetMask) >> kPartitionPageShift;
+      (pointer_as_uint & kSuperPageOffsetMask) >> PartitionPageShift();
   // Index 0 is invalid because it is the metadata and guard area and
   // the last index is invalid because it is a guard page.
   DCHECK(partition_page_index);
-  DCHECK(partition_page_index < kNumPartitionPagesPerSuperPage - 1);
+  DCHECK(partition_page_index < NumPartitionPagesPerSuperPage() - 1);
   PartitionPage* page = reinterpret_cast<PartitionPage*>(
       PartitionSuperPageToMetadataArea(super_page_ptr) +
       (partition_page_index << kPageMetadataShift));
@@ -169,20 +169,21 @@
 
   // A valid |page| must be past the first guard System page and within
   // the following metadata region.
-  DCHECK(super_page_offset > kSystemPageSize);
+  DCHECK(super_page_offset > SystemPageSize());
   // Must be less than total metadata region.
-  DCHECK(super_page_offset < kSystemPageSize + (kNumPartitionPagesPerSuperPage *
-                                                kPageMetadataSize));
+  DCHECK(super_page_offset <
+         SystemPageSize() +
+             (NumPartitionPagesPerSuperPage() * kPageMetadataSize));
   uintptr_t partition_page_index =
-      (super_page_offset - kSystemPageSize) >> kPageMetadataShift;
+      (super_page_offset - SystemPageSize()) >> kPageMetadataShift;
   // Index 0 is invalid because it is the superpage extent metadata and the
   // last index is invalid because the whole PartitionPage is set as guard
   // pages for the metadata region.
   DCHECK(partition_page_index);
-  DCHECK(partition_page_index < kNumPartitionPagesPerSuperPage - 1);
+  DCHECK(partition_page_index < NumPartitionPagesPerSuperPage() - 1);
   uintptr_t super_page_base = (pointer_as_uint & kSuperPageBaseMask);
   void* ret = reinterpret_cast<void*>(
-      super_page_base + (partition_page_index << kPartitionPageShift));
+      super_page_base + (partition_page_index << PartitionPageShift()));
   return ret;
 }
 
@@ -199,10 +200,10 @@
   // For single-slot buckets which span more than one partition page, we
   // have some spare metadata space to store the raw allocation size. We
   // can use this to report better statistics.
-  if (bucket->slot_size <= kMaxSystemPagesPerSlotSpan * kSystemPageSize)
+  if (bucket->slot_size <= MaxSystemPagesPerSlotSpan() * SystemPageSize())
     return nullptr;
 
-  DCHECK((bucket->slot_size % kSystemPageSize) == 0);
+  DCHECK((bucket->slot_size % SystemPageSize()) == 0);
   DCHECK(bucket->is_direct_mapped() || bucket->get_slots_per_span() == 1);
 
   const PartitionPage* the_next_page = this + 1;
diff --git a/third_party/base/allocator/partition_allocator/partition_root_base.h b/third_party/base/allocator/partition_allocator/partition_root_base.h
index 5d692b2..e394c3a 100644
--- a/third_party/base/allocator/partition_allocator/partition_root_base.h
+++ b/third_party/base/allocator/partition_allocator/partition_root_base.h
@@ -166,7 +166,7 @@
     PartitionPage* page) {
   PartitionSuperPageExtentEntry* extent_entry =
       reinterpret_cast<PartitionSuperPageExtentEntry*>(
-          reinterpret_cast<uintptr_t>(page) & kSystemPageBaseMask);
+          reinterpret_cast<uintptr_t>(page) & SystemPageBaseMask());
   return extent_entry->root;
 }