diff --git a/core/fxcrt/pdfium_span_unittest.cpp b/core/fxcrt/pdfium_span_unittest.cpp
index 0228fb2..7626eea 100644
--- a/core/fxcrt/pdfium_span_unittest.cpp
+++ b/core/fxcrt/pdfium_span_unittest.cpp
@@ -4,6 +4,7 @@
 
 #include <vector>
 
+#include "core/fxcrt/raw_span.h"
 #include "core/fxcrt/span.h"
 #include "core/fxcrt/unowned_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -57,7 +58,7 @@
 namespace {
 
 void CreateDanglingSpan() {
-  pdfium::span<int> data_span;
+  pdfium::raw_span<int> data_span;
   {
     std::vector<int> data(4);
     data_span = pdfium::make_span(data);
diff --git a/core/fxcrt/span.h b/core/fxcrt/span.h
index d7ecc9d..0a2ce62 100644
--- a/core/fxcrt/span.h
+++ b/core/fxcrt/span.h
@@ -16,29 +16,17 @@
 
 #include "core/fxcrt/check.h"
 #include "core/fxcrt/compiler_specific.h"
+#include "core/fxcrt/unowned_ptr_exclusion.h"
 
 // SAFETY: TODO(crbug.com/pdfium/2085): this entire file is to be replaced
 // with the fully annotated one that is being prepared in base/.
 
-#if defined(PDF_USE_PARTITION_ALLOC)
-UNSAFE_BUFFERS_INCLUDE_BEGIN
-#include "partition_alloc/pointers/raw_ptr.h"
-UNSAFE_BUFFERS_INCLUDE_END
-#else
-#include "core/fxcrt/unowned_ptr_exclusion.h"
-#endif
-
 namespace pdfium {
 
 constexpr size_t dynamic_extent = static_cast<size_t>(-1);
 
-#if defined(PDF_USE_PARTITION_ALLOC)
-template <typename T>
-using DefaultSpanInternalPtr = raw_ptr<T, AllowPtrArithmetic>;
-#else
 template <typename T>
 using DefaultSpanInternalPtr = UNOWNED_PTR_EXCLUSION T*;
-#endif
 
 template <typename T,
           size_t Extent = dynamic_extent,
@@ -257,8 +245,13 @@
 
   // Conversions from spans of compatible types: this allows a span<T> to be
   // seamlessly used as a span<const T>, but not the other way around.
-  template <typename U, typename = internal::EnableIfLegalSpanConversion<U, T>>
-  constexpr span(const span<U>& other) : span(other.data(), other.size()) {}
+  template <typename U,
+            size_t M,
+            typename R,
+            typename = internal::EnableIfLegalSpanConversion<U, T>>
+  constexpr span(const span<U, M, R>& other)
+      : span(other.data(), other.size()) {}
+
   span& operator=(const span& other) noexcept {
     if (this != &other) {
       data_ = other.data_;
@@ -338,25 +331,29 @@
 };
 
 // [span.objectrep], views of object representation
-template <typename T>
-span<const uint8_t> as_bytes(span<T> s) noexcept {
+template <typename T, size_t N, typename P>
+span<const uint8_t> as_bytes(span<T, N, P> s) noexcept {
   return {reinterpret_cast<const uint8_t*>(s.data()), s.size_bytes()};
 }
 
 template <typename T,
+          size_t N,
+          typename P,
           typename U = typename std::enable_if<!std::is_const<T>::value>::type>
-span<uint8_t> as_writable_bytes(span<T> s) noexcept {
+span<uint8_t> as_writable_bytes(span<T, N, P> s) noexcept {
   return {reinterpret_cast<uint8_t*>(s.data()), s.size_bytes()};
 }
 
-template <typename T>
-span<const char> as_chars(span<T> s) noexcept {
+template <typename T, size_t N, typename P>
+span<const char> as_chars(span<T, N, P> s) noexcept {
   return {reinterpret_cast<const char*>(s.data()), s.size_bytes()};
 }
 
 template <typename T,
+          size_t N,
+          typename P,
           typename U = typename std::enable_if<!std::is_const<T>::value>::type>
-span<char> as_writable_chars(span<T> s) noexcept {
+span<char> as_writable_chars(span<T, N, P> s) noexcept {
   return {reinterpret_cast<char*>(s.data()), s.size_bytes()};
 }
 
diff --git a/core/fxcrt/span_util.h b/core/fxcrt/span_util.h
index 65f32a0..936d956 100644
--- a/core/fxcrt/span_util.h
+++ b/core/fxcrt/span_util.h
@@ -18,12 +18,17 @@
 
 // Bounds-checked byte-for-byte copies from spans into spans. Returns a
 // span describing the remaining portion of the destination span.
-template <typename T,
-          typename U,
-          typename = std::enable_if_t<sizeof(T) == sizeof(U) &&
-                                      std::is_trivially_copyable_v<T> &&
-                                      std::is_trivially_copyable_v<U>>>
-pdfium::span<T> spancpy(pdfium::span<T> dst, pdfium::span<U> src) {
+template <typename T1,
+          typename T2,
+          size_t N1,
+          size_t N2,
+          typename P1,
+          typename P2,
+          typename = std::enable_if_t<sizeof(T1) == sizeof(T2) &&
+                                      std::is_trivially_copyable_v<T1> &&
+                                      std::is_trivially_copyable_v<T2>>>
+inline pdfium::span<T1> spancpy(pdfium::span<T1, N1, P1> dst,
+                                pdfium::span<T2, N2, P2> src) {
   CHECK_GE(dst.size(), src.size());
   FXSYS_memcpy(dst.data(), src.data(), src.size_bytes());
   return dst.subspan(src.size());
@@ -31,12 +36,17 @@
 
 // Bounds-checked byte-for-byte moves from spans into spans. Returns a
 // span describing the remaining portion of the destination span.
-template <typename T,
-          typename U,
-          typename = std::enable_if_t<sizeof(T) == sizeof(U) &&
-                                      std::is_trivially_copyable_v<T> &&
-                                      std::is_trivially_copyable_v<U>>>
-pdfium::span<T> spanmove(pdfium::span<T> dst, pdfium::span<U> src) {
+template <typename T1,
+          typename T2,
+          size_t N1,
+          size_t N2,
+          typename P1,
+          typename P2,
+          typename = std::enable_if_t<sizeof(T1) == sizeof(T2) &&
+                                      std::is_trivially_copyable_v<T1> &&
+                                      std::is_trivially_copyable_v<T2>>>
+pdfium::span<T1> spanmove(pdfium::span<T1, N1, P1> dst,
+                          pdfium::span<T2, N2, P2> src) {
   CHECK_GE(dst.size(), src.size());
   FXSYS_memmove(dst.data(), src.data(), src.size_bytes());
   return dst.subspan(src.size());
@@ -44,28 +54,36 @@
 
 // Bounds-checked sets into spans.
 template <typename T,
+          size_t N,
+          typename P,
           typename = std::enable_if_t<std::is_trivially_constructible_v<T> &&
                                       std::is_trivially_destructible_v<T>>>
-void spanset(pdfium::span<T> dst, uint8_t val) {
+void spanset(pdfium::span<T, N, P> dst, uint8_t val) {
   FXSYS_memset(dst.data(), val, dst.size_bytes());
 }
 
 // Bounds-checked zeroing of spans.
 template <typename T,
+          size_t N,
+          typename P,
           typename = std::enable_if_t<std::is_trivially_constructible_v<T> &&
                                       std::is_trivially_destructible_v<T>>>
-void spanclr(pdfium::span<T> dst) {
+void spanclr(pdfium::span<T, N, P> dst) {
   FXSYS_memset(dst.data(), 0, dst.size_bytes());
 }
 
 // Bounds-checked byte-for-byte equality of same-sized spans. This is
 // helpful because span does not (yet) have an operator==().
-template <typename T,
-          typename U,
-          typename = std::enable_if_t<sizeof(T) == sizeof(U) &&
-                                      std::is_trivially_copyable_v<T> &&
-                                      std::is_trivially_copyable_v<U>>>
-bool span_equals(pdfium::span<T> s1, pdfium::span<U> s2) {
+template <typename T1,
+          typename T2,
+          size_t N1,
+          size_t N2,
+          typename P1,
+          typename P2,
+          typename = std::enable_if_t<sizeof(T1) == sizeof(T2) &&
+                                      std::is_trivially_copyable_v<T1> &&
+                                      std::is_trivially_copyable_v<T2>>>
+bool span_equals(pdfium::span<T1, N1, P1> s1, pdfium::span<T2, N2, P2> s2) {
   return s1.size_bytes() == s2.size_bytes() &&
          FXSYS_memcmp(s1.data(), s2.data(), s1.size_bytes()) == 0;
 }