diff --git a/core/fpdfapi/edit/cpdf_creator.cpp b/core/fpdfapi/edit/cpdf_creator.cpp
index 47671df..1f33fce 100644
--- a/core/fpdfapi/edit/cpdf_creator.cpp
+++ b/core/fpdfapi/edit/cpdf_creator.cpp
@@ -40,7 +40,7 @@
   explicit CFX_FileBufferArchive(RetainPtr<IFX_RetainableWriteStream> file);
   ~CFX_FileBufferArchive() override;
 
-  bool WriteBlock(const void* pBuf, size_t size) override;
+  bool WriteBlock(pdfium::span<const uint8_t> buffer) override;
   FX_FILESIZE CurrentOffset() const override { return offset_; }
 
  private:
@@ -69,16 +69,14 @@
   available_ = pdfium::make_span(buffer_);
   if (!nUsed)
     return true;
-  return backing_file_->WriteBlock(buffer_.data(), nUsed);
+  return backing_file_->WriteBlock(available_.first(nUsed));
 }
 
-bool CFX_FileBufferArchive::WriteBlock(const void* pBuf, size_t size) {
-  if (size == 0)
+bool CFX_FileBufferArchive::WriteBlock(pdfium::span<const uint8_t> buffer) {
+  if (buffer.empty())
     return true;
 
-  DCHECK(pBuf);
-  auto* pSrc = reinterpret_cast<const uint8_t*>(pBuf);
-  pdfium::span<const uint8_t> src_span(pSrc, size);
+  pdfium::span<const uint8_t> src_span = buffer;
   while (!src_span.empty()) {
     size_t copy_size = std::min(available_.size(), src_span.size());
     fxcrt::spancpy(available_, src_span.first(copy_size));
@@ -89,7 +87,7 @@
   }
 
   FX_SAFE_FILESIZE safe_offset = offset_;
-  safe_offset += size;
+  safe_offset += buffer.size();
   if (!safe_offset.IsValid())
     return false;
 
diff --git a/core/fpdfapi/edit/cpdf_stringarchivestream.cpp b/core/fpdfapi/edit/cpdf_stringarchivestream.cpp
index 34e6b22..4d9f7f2 100644
--- a/core/fpdfapi/edit/cpdf_stringarchivestream.cpp
+++ b/core/fpdfapi/edit/cpdf_stringarchivestream.cpp
@@ -18,7 +18,7 @@
   return false;
 }
 
-bool CPDF_StringArchiveStream::WriteBlock(const void* pData, size_t size) {
-  stream_->write(static_cast<const char*>(pData), size);
+bool CPDF_StringArchiveStream::WriteBlock(pdfium::span<const uint8_t> buffer) {
+  stream_->write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
   return true;
 }
diff --git a/core/fpdfapi/edit/cpdf_stringarchivestream.h b/core/fpdfapi/edit/cpdf_stringarchivestream.h
index f822b56..1306343 100644
--- a/core/fpdfapi/edit/cpdf_stringarchivestream.h
+++ b/core/fpdfapi/edit/cpdf_stringarchivestream.h
@@ -14,7 +14,7 @@
   ~CPDF_StringArchiveStream() override;
 
   // IFX_ArchiveStream:
-  bool WriteBlock(const void* pData, size_t size) override;
+  bool WriteBlock(pdfium::span<const uint8_t> buffer) override;
   FX_FILESIZE CurrentOffset() const override;
 
  private:
diff --git a/core/fpdfapi/parser/cpdf_parser.cpp b/core/fpdfapi/parser/cpdf_parser.cpp
index 50a8011..aa85f81 100644
--- a/core/fpdfapi/parser/cpdf_parser.cpp
+++ b/core/fpdfapi/parser/cpdf_parser.cpp
@@ -1203,7 +1203,7 @@
         static_cast<uint32_t>(std::min(kBufferSize, src_size));
     if (!m_pSyntax->ReadBlock(buffer.data(), block_size))
       return false;
-    if (!archive->WriteBlock(buffer.data(), block_size))
+    if (!archive->WriteBlock(pdfium::make_span(buffer).first(block_size)))
       return false;
     src_size -= block_size;
   }
diff --git a/core/fpdfapi/parser/cpdf_seekablemultistream.cpp b/core/fpdfapi/parser/cpdf_seekablemultistream.cpp
index 50571d3..bad6d97 100644
--- a/core/fpdfapi/parser/cpdf_seekablemultistream.cpp
+++ b/core/fpdfapi/parser/cpdf_seekablemultistream.cpp
@@ -78,9 +78,9 @@
   return false;
 }
 
-bool CPDF_SeekableMultiStream::WriteBlockAtOffset(const void* pData,
-                                                  FX_FILESIZE offset,
-                                                  size_t size) {
+bool CPDF_SeekableMultiStream::WriteBlockAtOffset(
+    pdfium::span<const uint8_t> buffer,
+    FX_FILESIZE offset) {
   NOTREACHED();
   return false;
 }
diff --git a/core/fpdfapi/parser/cpdf_seekablemultistream.h b/core/fpdfapi/parser/cpdf_seekablemultistream.h
index a66194a..fc659a6 100644
--- a/core/fpdfapi/parser/cpdf_seekablemultistream.h
+++ b/core/fpdfapi/parser/cpdf_seekablemultistream.h
@@ -21,17 +21,16 @@
       std::vector<RetainPtr<const CPDF_Stream>> streams);
   ~CPDF_SeekableMultiStream() override;
 
-  // IFX_SeekableReadStream
+  // IFX_SeekableReadStream:
   FX_FILESIZE GetPosition() override;
   FX_FILESIZE GetSize() override;
+  bool IsEOF() override;
+  size_t ReadBlock(pdfium::span<uint8_t> buffer) override;
   bool ReadBlockAtOffset(pdfium::span<uint8_t> buffer,
                          FX_FILESIZE offset) override;
-  size_t ReadBlock(pdfium::span<uint8_t> buffer) override;
-  bool IsEOF() override;
+  bool WriteBlockAtOffset(pdfium::span<const uint8_t> buffer,
+                          FX_FILESIZE offset) override;
   bool Flush() override;
-  bool WriteBlockAtOffset(const void* pData,
-                          FX_FILESIZE offset,
-                          size_t size) override;
 
  private:
   std::vector<RetainPtr<CPDF_StreamAcc>> m_Data;
diff --git a/core/fpdfapi/parser/cpdf_stream.cpp b/core/fpdfapi/parser/cpdf_stream.cpp
index 9d9c0e3..89a34c9 100644
--- a/core/fpdfapi/parser/cpdf_stream.cpp
+++ b/core/fpdfapi/parser/cpdf_stream.cpp
@@ -174,7 +174,7 @@
   if (!archive->WriteString("stream\r\n"))
     return false;
 
-  if (!archive->WriteSpan(data))
+  if (!archive->WriteBlock(data))
     return false;
 
   return archive->WriteString("\r\nendstream");
diff --git a/core/fxcrt/cfx_memorystream.cpp b/core/fxcrt/cfx_memorystream.cpp
index 7d05992..32bb360 100644
--- a/core/fxcrt/cfx_memorystream.cpp
+++ b/core/fxcrt/cfx_memorystream.cpp
@@ -67,17 +67,15 @@
   return nRead;
 }
 
-bool CFX_MemoryStream::WriteBlockAtOffset(const void* buffer,
-                                          FX_FILESIZE offset,
-                                          size_t size) {
+bool CFX_MemoryStream::WriteBlockAtOffset(pdfium::span<const uint8_t> buffer,
+                                          FX_FILESIZE offset) {
   if (offset < 0)
     return false;
 
-  if (size == 0)
+  if (buffer.empty())
     return true;
 
-  DCHECK(buffer);
-  FX_SAFE_SIZE_T safe_new_pos = size;
+  FX_SAFE_SIZE_T safe_new_pos = buffer.size();
   safe_new_pos += offset;
   if (!safe_new_pos.IsValid())
     return false;
@@ -100,7 +98,7 @@
   // Safe to cast `offset` because it was used to calculate `safe_new_pos`
   // above, and `safe_new_pos` is valid.
   fxcrt::spancpy(pdfium::make_span(m_data).subspan(static_cast<size_t>(offset)),
-                 pdfium::make_span(static_cast<const uint8_t*>(buffer), size));
+                 buffer);
   m_nCurSize = std::max(m_nCurSize, m_nCurPos);
 
   return true;
diff --git a/core/fxcrt/cfx_memorystream.h b/core/fxcrt/cfx_memorystream.h
index 858efa0..5ecf995 100644
--- a/core/fxcrt/cfx_memorystream.h
+++ b/core/fxcrt/cfx_memorystream.h
@@ -20,12 +20,11 @@
   FX_FILESIZE GetSize() override;
   FX_FILESIZE GetPosition() override;
   bool IsEOF() override;
+  size_t ReadBlock(pdfium::span<uint8_t> buffer) override;
   bool ReadBlockAtOffset(pdfium::span<uint8_t> buffer,
                          FX_FILESIZE offset) override;
-  size_t ReadBlock(pdfium::span<uint8_t> buffer) override;
-  bool WriteBlockAtOffset(const void* buffer,
-                          FX_FILESIZE offset,
-                          size_t size) override;
+  bool WriteBlockAtOffset(pdfium::span<const uint8_t> buffer,
+                          FX_FILESIZE offset) override;
   bool Flush() override;
 
   pdfium::span<const uint8_t> GetSpan() const;
diff --git a/core/fxcrt/cfx_memorystream_unittest.cpp b/core/fxcrt/cfx_memorystream_unittest.cpp
index 445e1c9..88b0e25 100644
--- a/core/fxcrt/cfx_memorystream_unittest.cpp
+++ b/core/fxcrt/cfx_memorystream_unittest.cpp
@@ -17,27 +17,29 @@
 
 TEST(CFXMemoryStreamTest, SparseBlockWrites) {
   auto stream = pdfium::MakeRetain<CFX_MemoryStream>();
-  for (FX_FILESIZE offset = 0; offset <= 200000; offset += 100000)
-    stream->WriteBlockAtOffset(kSomeText, offset, kSomeTextLen);
-
+  for (FX_FILESIZE offset = 0; offset <= 200000; offset += 100000) {
+    stream->WriteBlockAtOffset(
+        {reinterpret_cast<const uint8_t*>(kSomeText), kSomeTextLen}, offset);
+  }
   EXPECT_EQ(200000 + kSomeTextLen, static_cast<size_t>(stream->GetSize()));
 }
 
 TEST(CFXMemoryStreamTest, OverlappingBlockWrites) {
   auto stream = pdfium::MakeRetain<CFX_MemoryStream>();
-  for (FX_FILESIZE offset = 0; offset <= 100; ++offset)
-    stream->WriteBlockAtOffset(kSomeText, offset, kSomeTextLen);
-
+  for (FX_FILESIZE offset = 0; offset <= 100; ++offset) {
+    stream->WriteBlockAtOffset(
+        {reinterpret_cast<const uint8_t*>(kSomeText), kSomeTextLen}, offset);
+  }
   EXPECT_EQ(100 + kSomeTextLen, static_cast<size_t>(stream->GetSize()));
 }
 
 TEST(CFXMemoryStreamTest, ReadWriteBlockAtOffset) {
   auto stream = pdfium::MakeRetain<CFX_MemoryStream>();
   const uint8_t kData1[] = {'a', 'b', 'c'};
-  ASSERT_TRUE(stream->WriteBlock(kData1, sizeof(kData1)));
+  ASSERT_TRUE(stream->WriteBlock(kData1));
   ASSERT_THAT(stream->GetSpan(), testing::ElementsAre('a', 'b', 'c'));
 
-  ASSERT_TRUE(stream->WriteBlockAtOffset(kData1, 5, sizeof(kData1)));
+  ASSERT_TRUE(stream->WriteBlockAtOffset(kData1, 5));
   ASSERT_THAT(stream->GetSpan(),
               testing::ElementsAre('a', 'b', 'c', '\0', '\0', 'a', 'b', 'c'));
 
@@ -49,12 +51,9 @@
 TEST(CFXMemoryStreamTest, WriteZeroBytes) {
   auto stream = pdfium::MakeRetain<CFX_MemoryStream>();
   const uint8_t kData1[] = {'a', 'b', 'c'};
-  ASSERT_TRUE(stream->WriteBlock(kData1, sizeof(kData1)));
+  ASSERT_TRUE(stream->WriteBlock(kData1));
   ASSERT_THAT(stream->GetSpan(), testing::ElementsAre('a', 'b', 'c'));
 
-  ASSERT_TRUE(stream->WriteBlock(kData1, 0));
-  ASSERT_THAT(stream->GetSpan(), testing::ElementsAre('a', 'b', 'c'));
-
-  ASSERT_TRUE(stream->WriteBlock(nullptr, 0));
+  ASSERT_TRUE(stream->WriteBlock({}));
   ASSERT_THAT(stream->GetSpan(), testing::ElementsAre('a', 'b', 'c'));
 }
diff --git a/core/fxcrt/fx_stream.cpp b/core/fxcrt/fx_stream.cpp
index 31ddbf8..1ceb539 100644
--- a/core/fxcrt/fx_stream.cpp
+++ b/core/fxcrt/fx_stream.cpp
@@ -28,10 +28,9 @@
   size_t ReadBlock(pdfium::span<uint8_t> buffer) override {
     return m_pFile->Read(buffer.data(), buffer.size());
   }
-  bool WriteBlockAtOffset(const void* buffer,
-                          FX_FILESIZE offset,
-                          size_t size) override {
-    return !!m_pFile->WritePos(buffer, size, offset);
+  bool WriteBlockAtOffset(pdfium::span<const uint8_t> buffer,
+                          FX_FILESIZE offset) override {
+    return !!m_pFile->WritePos(buffer.data(), buffer.size(), offset);
   }
   bool Flush() override { return m_pFile->Flush(); }
 
@@ -45,28 +44,24 @@
 
 }  // namespace
 
-bool IFX_WriteStream::WriteSpan(pdfium::span<const uint8_t> data) {
-  return WriteBlock(data.data(), data.size());
-}
-
 bool IFX_WriteStream::WriteString(ByteStringView str) {
-  return WriteBlock(str.unterminated_c_str(), str.GetLength());
+  return WriteBlock(str.raw_span());
 }
 
 bool IFX_WriteStream::WriteByte(uint8_t byte) {
-  return WriteBlock(&byte, 1);
+  return WriteBlock({&byte, 1});
 }
 
 bool IFX_WriteStream::WriteDWord(uint32_t i) {
   char buf[20] = {};
   FXSYS_itoa(i, buf, 10);
-  return WriteBlock(buf, strlen(buf));
+  return WriteBlock({reinterpret_cast<uint8_t*>(buf), strlen(buf)});
 }
 
 bool IFX_WriteStream::WriteFilesize(FX_FILESIZE size) {
   char buf[20] = {};
   FXSYS_i64toa(size, buf, 10);
-  return WriteBlock(buf, strlen(buf));
+  return WriteBlock({reinterpret_cast<uint8_t*>(buf), strlen(buf)});
 }
 
 // static
@@ -78,8 +73,8 @@
   return pdfium::MakeRetain<CFX_CRTFileStream>(std::move(pFA));
 }
 
-bool IFX_SeekableWriteStream::WriteBlock(const void* pData, size_t size) {
-  return WriteBlockAtOffset(pData, GetSize(), size);
+bool IFX_SeekableWriteStream::WriteBlock(pdfium::span<const uint8_t> buffer) {
+  return WriteBlockAtOffset(buffer, GetSize());
 }
 
 bool IFX_SeekableReadStream::IsEOF() {
@@ -94,6 +89,6 @@
   return 0;
 }
 
-bool IFX_SeekableStream::WriteBlock(const void* buffer, size_t size) {
-  return WriteBlockAtOffset(buffer, GetSize(), size);
+bool IFX_SeekableStream::WriteBlock(pdfium::span<const uint8_t> buffer) {
+  return WriteBlockAtOffset(buffer, GetSize());
 }
diff --git a/core/fxcrt/fx_stream.h b/core/fxcrt/fx_stream.h
index a2a04f2..46d7de9 100644
--- a/core/fxcrt/fx_stream.h
+++ b/core/fxcrt/fx_stream.h
@@ -17,11 +17,9 @@
 
 class IFX_WriteStream {
  public:
-  // When `size` is 0, treat it as a no-op and return true. That is also the
-  // only time when `pData` can be null.
-  virtual bool WriteBlock(const void* pData, size_t size) = 0;
+  // When `size` is 0, treat it as a no-op and return true.
+  virtual bool WriteBlock(pdfium::span<const uint8_t> data) = 0;
 
-  bool WriteSpan(pdfium::span<const uint8_t> data);
   bool WriteString(ByteStringView str);
   bool WriteByte(uint8_t byte);
   bool WriteDWord(uint32_t i);
@@ -48,12 +46,11 @@
                                 public IFX_RetainableWriteStream {
  public:
   // IFX_WriteStream:
-  bool WriteBlock(const void* pData, size_t size) override;
+  bool WriteBlock(pdfium::span<const uint8_t> data) override;
 
   virtual bool Flush() = 0;
-  virtual bool WriteBlockAtOffset(const void* pData,
-                                  FX_FILESIZE offset,
-                                  size_t size) = 0;
+  virtual bool WriteBlockAtOffset(pdfium::span<const uint8_t> data,
+                                  FX_FILESIZE offset) = 0;
 };
 
 class IFX_SeekableReadStream : virtual public Retainable,
@@ -73,7 +70,7 @@
                            public IFX_SeekableWriteStream {
  public:
   // IFX_SeekableWriteStream:
-  bool WriteBlock(const void* buffer, size_t size) override;
+  bool WriteBlock(pdfium::span<const uint8_t> buffer) override;
 };
 
 #endif  // CORE_FXCRT_FX_STREAM_H_
diff --git a/core/fxge/win32/cfx_psrenderer.cpp b/core/fxge/win32/cfx_psrenderer.cpp
index ddbc245..8f15ce4 100644
--- a/core/fxge/win32/cfx_psrenderer.cpp
+++ b/core/fxge/win32/cfx_psrenderer.cpp
@@ -276,15 +276,16 @@
   // Flush `m_PreambleOutput` if it is not empty.
   std::streamoff preamble_pos = m_PreambleOutput.tellp();
   if (preamble_pos > 0) {
-    m_pStream->WriteBlock(m_PreambleOutput.str().c_str(),
-                          pdfium::base::checked_cast<size_t>(preamble_pos));
+    m_pStream->WriteBlock(
+        {reinterpret_cast<const uint8_t*>(m_PreambleOutput.str().c_str()),
+         pdfium::base::checked_cast<size_t>(preamble_pos)});
     m_PreambleOutput.str("");
   }
 
   // Flush `m_Output`. It's never empty because of the WriteString() call above.
   m_pStream->WriteBlock(
-      m_Output.str().c_str(),
-      pdfium::base::checked_cast<size_t>(std::streamoff(m_Output.tellp())));
+      {reinterpret_cast<const uint8_t*>(m_Output.str().c_str()),
+       pdfium::base::checked_cast<size_t>(std::streamoff(m_Output.tellp()))});
   m_Output.str("");
 }
 
diff --git a/core/fxge/win32/cfx_psrenderer_unittest.cpp b/core/fxge/win32/cfx_psrenderer_unittest.cpp
index 1389507..81430df 100644
--- a/core/fxge/win32/cfx_psrenderer_unittest.cpp
+++ b/core/fxge/win32/cfx_psrenderer_unittest.cpp
@@ -27,9 +27,8 @@
   CONSTRUCT_VIA_MAKE_RETAIN;
 
   // IFX_RetainableWriteStream:
-  bool WriteBlock(const void* pData, size_t size) override {
-    const uint8_t* data_as_uint8 = static_cast<const uint8_t*>(pData);
-    data_.insert(data_.end(), data_as_uint8, data_as_uint8 + size);
+  bool WriteBlock(pdfium::span<const uint8_t> buffer) override {
+    data_.insert(data_.end(), buffer.begin(), buffer.end());
     return true;
   }
 
diff --git a/core/fxge/win32/cpsoutput.cpp b/core/fxge/win32/cpsoutput.cpp
index 6f349c4..763a4e5 100644
--- a/core/fxge/win32/cpsoutput.cpp
+++ b/core/fxge/win32/cpsoutput.cpp
@@ -15,14 +15,12 @@
 
 CPSOutput::~CPSOutput() = default;
 
-bool CPSOutput::WriteBlock(const void* str, size_t len) {
-  pdfium::span<const uint8_t> input(static_cast<const uint8_t*>(str), len);
+bool CPSOutput::WriteBlock(pdfium::span<const uint8_t> input) {
   while (!input.empty()) {
     uint8_t buffer[1026];
     size_t send_len = std::min<size_t>(input.size(), 1024);
     *(reinterpret_cast<uint16_t*>(buffer)) = static_cast<uint16_t>(send_len);
     memcpy(buffer + 2, input.data(), send_len);
-
     switch (m_mode) {
       case OutputMode::kExtEscape:
         ExtEscape(m_hDC, PASSTHROUGH, static_cast<int>(send_len + 2),
diff --git a/core/fxge/win32/cpsoutput.h b/core/fxge/win32/cpsoutput.h
index 62ac7c0..efb93ce 100644
--- a/core/fxge/win32/cpsoutput.h
+++ b/core/fxge/win32/cpsoutput.h
@@ -20,7 +20,7 @@
   ~CPSOutput() override;
 
   // IFX_Writestream:
-  bool WriteBlock(const void* str, size_t len) override;
+  bool WriteBlock(pdfium::span<const uint8_t> input) override;
 
  private:
   const HDC m_hDC;
diff --git a/fpdfsdk/cpdfsdk_filewriteadapter.cpp b/fpdfsdk/cpdfsdk_filewriteadapter.cpp
index 5d138d6..776c8de 100644
--- a/fpdfsdk/cpdfsdk_filewriteadapter.cpp
+++ b/fpdfsdk/cpdfsdk_filewriteadapter.cpp
@@ -16,8 +16,8 @@
 
 CPDFSDK_FileWriteAdapter::~CPDFSDK_FileWriteAdapter() = default;
 
-bool CPDFSDK_FileWriteAdapter::WriteBlock(const void* data, size_t size) {
+bool CPDFSDK_FileWriteAdapter::WriteBlock(pdfium::span<const uint8_t> buffer) {
   return file_write_->WriteBlock(
-             file_write_, data,
-             pdfium::base::checked_cast<unsigned long>(size)) != 0;
+             file_write_, buffer.data(),
+             pdfium::base::checked_cast<unsigned long>(buffer.size())) != 0;
 }
diff --git a/fpdfsdk/cpdfsdk_filewriteadapter.h b/fpdfsdk/cpdfsdk_filewriteadapter.h
index 0b210b5..477ec90 100644
--- a/fpdfsdk/cpdfsdk_filewriteadapter.h
+++ b/fpdfsdk/cpdfsdk_filewriteadapter.h
@@ -17,7 +17,7 @@
   CONSTRUCT_VIA_MAKE_RETAIN;
 
   // IFX_WriteStream:
-  bool WriteBlock(const void* data, size_t size) override;
+  bool WriteBlock(pdfium::span<const uint8_t> buffer) override;
 
  private:
   explicit CPDFSDK_FileWriteAdapter(FPDF_FILEWRITE* file_write);
diff --git a/fpdfsdk/cpdfsdk_helpers.cpp b/fpdfsdk/cpdfsdk_helpers.cpp
index 3727b28..f43b692 100644
--- a/fpdfsdk/cpdfsdk_helpers.cpp
+++ b/fpdfsdk/cpdfsdk_helpers.cpp
@@ -82,14 +82,13 @@
 
   // IFX_SeekableStream:
   FX_FILESIZE GetSize() override;
-  bool IsEOF() override;
   FX_FILESIZE GetPosition() override;
+  bool IsEOF() override;
+  size_t ReadBlock(pdfium::span<uint8_t> buffer) override;
   bool ReadBlockAtOffset(pdfium::span<uint8_t> buffer,
                          FX_FILESIZE offset) override;
-  size_t ReadBlock(pdfium::span<uint8_t> buffer) override;
-  bool WriteBlockAtOffset(const void* buffer,
-                          FX_FILESIZE offset,
-                          size_t size) override;
+  bool WriteBlockAtOffset(pdfium::span<const uint8_t> buffer,
+                          FX_FILESIZE offset) override;
   bool Flush() override;
 
   void SetPosition(FX_FILESIZE pos) { m_nCurPos = pos; }
@@ -158,15 +157,16 @@
   return 0;
 }
 
-bool FPDF_FileHandlerContext::WriteBlockAtOffset(const void* buffer,
-                                                 FX_FILESIZE offset,
-                                                 size_t size) {
+bool FPDF_FileHandlerContext::WriteBlockAtOffset(
+    pdfium::span<const uint8_t> buffer,
+    FX_FILESIZE offset) {
   if (!m_pFS || !m_pFS->WriteBlock)
     return false;
 
-  if (m_pFS->WriteBlock(m_pFS->clientData, (FPDF_DWORD)offset, buffer,
-                        (FPDF_DWORD)size) == 0) {
-    m_nCurPos = offset + size;
+  if (m_pFS->WriteBlock(m_pFS->clientData, static_cast<FPDF_DWORD>(offset),
+                        buffer.data(),
+                        static_cast<FPDF_DWORD>(buffer.size())) == 0) {
+    m_nCurPos = offset + buffer.size();
     return true;
   }
   return false;
diff --git a/fpdfsdk/fpdfxfa/cpdfxfa_docenvironment.cpp b/fpdfsdk/fpdfxfa/cpdfxfa_docenvironment.cpp
index e2721fb..ca71694 100644
--- a/fpdfsdk/fpdfxfa/cpdfxfa_docenvironment.cpp
+++ b/fpdfsdk/fpdfxfa/cpdfxfa_docenvironment.cpp
@@ -514,7 +514,7 @@
       }
       auto pAcc = pdfium::MakeRetain<CPDF_StreamAcc>(std::move(pStream));
       pAcc->LoadAllDataFiltered();
-      fileWrite->WriteSpan(pAcc->GetSpan());
+      fileWrite->WriteBlock(pAcc->GetSpan());
     }
   }
   fileWrite->Flush();
diff --git a/testing/string_write_stream.cpp b/testing/string_write_stream.cpp
index 334ff93..1a99d9a 100644
--- a/testing/string_write_stream.cpp
+++ b/testing/string_write_stream.cpp
@@ -11,7 +11,7 @@
 
 StringWriteStream::~StringWriteStream() = default;
 
-bool StringWriteStream::WriteBlock(const void* pData, size_t size) {
-  stream_.write(static_cast<const char*>(pData), size);
+bool StringWriteStream::WriteBlock(pdfium::span<const uint8_t> buffer) {
+  stream_.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
   return true;
 }
diff --git a/testing/string_write_stream.h b/testing/string_write_stream.h
index 747b96e..fc4dc02 100644
--- a/testing/string_write_stream.h
+++ b/testing/string_write_stream.h
@@ -16,7 +16,7 @@
   ~StringWriteStream() override;
 
   // IFX_WriteStream:
-  bool WriteBlock(const void* pData, size_t size) override;
+  bool WriteBlock(pdfium::span<const uint8_t> buffer) override;
 
   std::string ToString() const { return stream_.str(); }