diff --git a/core/fxge/dib/cfx_bitmapcomposer.cpp b/core/fxge/dib/cfx_bitmapcomposer.cpp
index 75c9bea..23a59bd 100644
--- a/core/fxge/dib/cfx_bitmapcomposer.cpp
+++ b/core/fxge/dib/cfx_bitmapcomposer.cpp
@@ -70,11 +70,11 @@
 }
 
 void CFX_BitmapComposer::DoCompose(uint8_t* dest_scan,
-                                   const uint8_t* src_scan,
+                                   pdfium::span<const uint8_t> src_scan,
                                    int dest_width,
                                    const uint8_t* clip_scan,
-                                   const uint8_t* src_extra_alpha,
-                                   uint8_t* dst_extra_alpha) {
+                                   pdfium::span<const uint8_t> src_extra_alpha,
+                                   pdfium::span<uint8_t> dst_extra_alpha) {
   uint8_t* pAddClipScan = m_pAddClipScan.data();
   if (m_BitmapAlpha < 255) {
     if (clip_scan) {
@@ -99,9 +99,10 @@
   }
 }
 
-void CFX_BitmapComposer::ComposeScanline(int line,
-                                         const uint8_t* scanline,
-                                         const uint8_t* scan_extra_alpha) {
+void CFX_BitmapComposer::ComposeScanline(
+    int line,
+    pdfium::span<const uint8_t> scanline,
+    pdfium::span<const uint8_t> scan_extra_alpha) {
   if (m_bVertical) {
     ComposeScanlineV(line, scanline, scan_extra_alpha);
     return;
@@ -124,18 +125,19 @@
     // Help some compilers perform pointer arithmetic against safe numerics.
     dest_scan += static_cast<uint32_t>(offset.ValueOrDie());
   }
-  uint8_t* dest_alpha_scan =
-      m_pBitmap->GetWritableAlphaMaskScanline(line + m_DestTop).data();
-  if (dest_alpha_scan)
-    dest_alpha_scan += m_DestLeft;
+  pdfium::span<uint8_t> dest_alpha_scan =
+      m_pBitmap->GetWritableAlphaMaskScanline(line + m_DestTop);
+  if (!dest_alpha_scan.empty())
+    dest_alpha_scan = dest_alpha_scan.subspan(m_DestLeft);
 
   DoCompose(dest_scan, scanline, m_DestWidth, clip_scan, scan_extra_alpha,
             dest_alpha_scan);
 }
 
-void CFX_BitmapComposer::ComposeScanlineV(int line,
-                                          const uint8_t* scanline,
-                                          const uint8_t* scan_extra_alpha) {
+void CFX_BitmapComposer::ComposeScanlineV(
+    int line,
+    pdfium::span<const uint8_t> scanline,
+    pdfium::span<const uint8_t> scan_extra_alpha) {
   int Bpp = m_pBitmap->GetBPP() / 8;
   int dest_pitch = m_pBitmap->GetPitch();
   int dest_alpha_pitch = m_pBitmap->GetAlphaMaskPitch();
@@ -191,7 +193,7 @@
     }
   }
   DoCompose(m_pScanlineV.data(), scanline, m_DestHeight, clip_scan,
-            scan_extra_alpha, m_pScanlineAlphaV.data());
+            scan_extra_alpha, m_pScanlineAlphaV);
   src_scan = m_pScanlineV.data();
   dest_scan = dest_buf;
   for (int i = 0; i < m_DestHeight; ++i) {
diff --git a/core/fxge/dib/cfx_bitmapcomposer.h b/core/fxge/dib/cfx_bitmapcomposer.h
index 30f7132..f38297d 100644
--- a/core/fxge/dib/cfx_bitmapcomposer.h
+++ b/core/fxge/dib/cfx_bitmapcomposer.h
@@ -43,19 +43,19 @@
                pdfium::span<const uint32_t> src_palette) override;
 
   void ComposeScanline(int line,
-                       const uint8_t* scanline,
-                       const uint8_t* scan_extra_alpha) override;
+                       pdfium::span<const uint8_t> scanline,
+                       pdfium::span<const uint8_t> scan_extra_alpha) override;
 
  private:
   void DoCompose(uint8_t* dest_scan,
-                 const uint8_t* src_scan,
+                 pdfium::span<const uint8_t> src_scan,
                  int dest_width,
                  const uint8_t* clip_scan,
-                 const uint8_t* src_extra_alpha,
-                 uint8_t* dst_extra_alpha);
+                 pdfium::span<const uint8_t> src_extra_alpha,
+                 pdfium::span<uint8_t> dst_extra_alpha);
   void ComposeScanlineV(int line,
-                        const uint8_t* scanline,
-                        const uint8_t* scan_extra_alpha);
+                        pdfium::span<const uint8_t> scanline,
+                        pdfium::span<const uint8_t> scan_extra_alpha);
 
   RetainPtr<CFX_DIBitmap> m_pBitmap;
   UnownedPtr<const CFX_ClipRgn> m_pClipRgn;
diff --git a/core/fxge/dib/cfx_bitmapstorer.cpp b/core/fxge/dib/cfx_bitmapstorer.cpp
index 2de8ba8..c3443a2 100644
--- a/core/fxge/dib/cfx_bitmapstorer.cpp
+++ b/core/fxge/dib/cfx_bitmapstorer.cpp
@@ -10,6 +10,7 @@
 
 #include <utility>
 
+#include "core/fxcrt/span_util.h"
 #include "core/fxge/dib/cfx_dibitmap.h"
 
 CFX_BitmapStorer::CFX_BitmapStorer() = default;
@@ -24,17 +25,18 @@
   m_pBitmap = std::move(pBitmap);
 }
 
-void CFX_BitmapStorer::ComposeScanline(int line,
-                                       const uint8_t* scanline,
-                                       const uint8_t* scan_extra_alpha) {
-  uint8_t* dest_buf = m_pBitmap->GetWritableScanline(line).data();
-  if (dest_buf)
-    memcpy(dest_buf, scanline, m_pBitmap->GetPitch());
+void CFX_BitmapStorer::ComposeScanline(
+    int line,
+    pdfium::span<const uint8_t> scanline,
+    pdfium::span<const uint8_t> scan_extra_alpha) {
+  pdfium::span<uint8_t> dest_buf = m_pBitmap->GetWritableScanline(line);
+  if (!dest_buf.empty())
+    fxcrt::spancpy(dest_buf, scanline);
 
-  uint8_t* dest_alpha_buf =
-      m_pBitmap->GetWritableAlphaMaskScanline(line).data();
-  if (dest_alpha_buf)
-    memcpy(dest_alpha_buf, scan_extra_alpha, m_pBitmap->GetAlphaMaskPitch());
+  pdfium::span<uint8_t> dest_alpha_buf =
+      m_pBitmap->GetWritableAlphaMaskScanline(line);
+  if (!dest_alpha_buf.empty())
+    fxcrt::spancpy(dest_alpha_buf, scan_extra_alpha);
 }
 
 bool CFX_BitmapStorer::SetInfo(int width,
diff --git a/core/fxge/dib/cfx_bitmapstorer.h b/core/fxge/dib/cfx_bitmapstorer.h
index 3145875..7427691 100644
--- a/core/fxge/dib/cfx_bitmapstorer.h
+++ b/core/fxge/dib/cfx_bitmapstorer.h
@@ -9,6 +9,7 @@
 
 #include "core/fxcrt/retain_ptr.h"
 #include "core/fxge/dib/scanlinecomposer_iface.h"
+#include "third_party/base/span.h"
 
 class CFX_DIBitmap;
 
@@ -19,8 +20,8 @@
 
   // ScanlineComposerIface:
   void ComposeScanline(int line,
-                       const uint8_t* scanline,
-                       const uint8_t* scan_extra_alpha) override;
+                       pdfium::span<const uint8_t> scanline,
+                       pdfium::span<const uint8_t> scan_extra_alpha) override;
   bool SetInfo(int width,
                int height,
                FXDIB_Format src_format,
diff --git a/core/fxge/dib/cfx_dibitmap.cpp b/core/fxge/dib/cfx_dibitmap.cpp
index 7ce6a73..8ef8b82 100644
--- a/core/fxge/dib/cfx_dibitmap.cpp
+++ b/core/fxge/dib/cfx_dibitmap.cpp
@@ -767,18 +767,16 @@
   for (int row = 0; row < height; row++) {
     uint8_t* dest_scan =
         m_pBuffer.Get() + (dest_top + row) * m_Pitch + dest_left * dest_Bpp;
-    const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row)
-                                  .subspan(src_left * src_Bpp)
-                                  .data();
-    const uint8_t* src_scan_extra_alpha =
+    pdfium::span<const uint8_t> src_scan =
+        pSrcBitmap->GetScanline(src_top + row).subspan(src_left * src_Bpp);
+    pdfium::span<const uint8_t> src_scan_extra_alpha =
         pSrcAlphaMask
-            ? pSrcAlphaMask->GetScanline(src_top + row).subspan(src_left).data()
-            : nullptr;
-    uint8_t* dst_scan_extra_alpha =
+            ? pSrcAlphaMask->GetScanline(src_top + row).subspan(src_left)
+            : pdfium::span<const uint8_t>();
+    pdfium::span<uint8_t> dst_scan_extra_alpha =
         m_pAlphaMask ? m_pAlphaMask->GetWritableScanline(dest_top + row)
                            .subspan(dest_left)
-                           .data()
-                     : nullptr;
+                     : pdfium::span<uint8_t>();
     const uint8_t* clip_scan = nullptr;
     if (pClipMask) {
       clip_scan = pClipMask->m_pBuffer.Get() +
@@ -846,12 +844,11 @@
   for (int row = 0; row < height; row++) {
     uint8_t* dest_scan =
         m_pBuffer.Get() + (dest_top + row) * m_Pitch + dest_left * Bpp;
-    const uint8_t* src_scan = pMask->GetScanline(src_top + row).data();
-    uint8_t* dst_scan_extra_alpha =
+    pdfium::span<const uint8_t> src_scan = pMask->GetScanline(src_top + row);
+    pdfium::span<uint8_t> dst_scan_extra_alpha =
         m_pAlphaMask ? m_pAlphaMask->GetWritableScanline(dest_top + row)
                            .subspan(dest_left)
-                           .data()
-                     : nullptr;
+                     : pdfium::span<uint8_t>();
     const uint8_t* clip_scan = nullptr;
     if (pClipMask) {
       clip_scan = pClipMask->m_pBuffer.Get() +
@@ -862,8 +859,8 @@
       compositor.CompositeBitMaskLine(dest_scan, src_scan, src_left, width,
                                       clip_scan, dst_scan_extra_alpha);
     } else {
-      compositor.CompositeByteMaskLine(dest_scan, src_scan + src_left, width,
-                                       clip_scan, dst_scan_extra_alpha);
+      compositor.CompositeByteMaskLine(dest_scan, src_scan.subspan(src_left),
+                                       width, clip_scan, dst_scan_extra_alpha);
     }
   }
   return true;
diff --git a/core/fxge/dib/cfx_scanlinecompositor.cpp b/core/fxge/dib/cfx_scanlinecompositor.cpp
index c04c6dc..858176c 100644
--- a/core/fxge/dib/cfx_scanlinecompositor.cpp
+++ b/core/fxge/dib/cfx_scanlinecompositor.cpp
@@ -2773,11 +2773,11 @@
 
 void CFX_ScanlineCompositor::CompositeRgbBitmapLine(
     uint8_t* dest_scan,
-    const uint8_t* src_scan,
+    pdfium::span<const uint8_t> src_scan,
     int width,
     const uint8_t* clip_scan,
-    const uint8_t* src_extra_alpha,
-    uint8_t* dst_extra_alpha) {
+    pdfium::span<const uint8_t> src_extra_alpha,
+    pdfium::span<uint8_t> dst_extra_alpha) {
   int src_Bpp = GetCompsFromFormat(m_SrcFormat);
   int dest_Bpp = GetCompsFromFormat(m_DestFormat);
   if (m_bRgbByteOrder) {
@@ -2786,51 +2786,52 @@
       case 4:
       case 8:
       case 12:
-        CompositeRow_Argb2Argb_RgbByteOrder(dest_scan, src_scan, width,
+        CompositeRow_Argb2Argb_RgbByteOrder(dest_scan, src_scan.data(), width,
                                             m_BlendType, clip_scan);
         break;
       case 1:
         CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(
-            dest_scan, src_scan, width, m_BlendType, src_Bpp);
+            dest_scan, src_scan.data(), width, m_BlendType, src_Bpp);
         break;
       case 2:
       case 10:
-        CompositeRow_Argb2Rgb_Blend_RgbByteOrder(
-            dest_scan, src_scan, width, m_BlendType, dest_Bpp, clip_scan);
+        CompositeRow_Argb2Rgb_Blend_RgbByteOrder(dest_scan, src_scan.data(),
+                                                 width, m_BlendType, dest_Bpp,
+                                                 clip_scan);
         break;
       case 3:
         CompositeRow_Rgb2Rgb_Blend_NoClip_RgbByteOrder(
-            dest_scan, src_scan, width, m_BlendType, dest_Bpp, src_Bpp);
+            dest_scan, src_scan.data(), width, m_BlendType, dest_Bpp, src_Bpp);
         break;
       case 5:
-        CompositeRow_Rgb2Argb_NoBlend_NoClip_RgbByteOrder(dest_scan, src_scan,
-                                                          width, src_Bpp);
+        CompositeRow_Rgb2Argb_NoBlend_NoClip_RgbByteOrder(
+            dest_scan, src_scan.data(), width, src_Bpp);
         break;
       case 6:
       case 14:
-        CompositeRow_Argb2Rgb_NoBlend_RgbByteOrder(dest_scan, src_scan, width,
-                                                   dest_Bpp, clip_scan);
+        CompositeRow_Argb2Rgb_NoBlend_RgbByteOrder(dest_scan, src_scan.data(),
+                                                   width, dest_Bpp, clip_scan);
         break;
       case 7:
         CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder(
-            dest_scan, src_scan, width, dest_Bpp, src_Bpp);
+            dest_scan, src_scan.data(), width, dest_Bpp, src_Bpp);
         break;
       case 9:
         CompositeRow_Rgb2Argb_Blend_Clip_RgbByteOrder(
-            dest_scan, src_scan, width, m_BlendType, src_Bpp, clip_scan);
+            dest_scan, src_scan.data(), width, m_BlendType, src_Bpp, clip_scan);
         break;
       case 11:
-        CompositeRow_Rgb2Rgb_Blend_Clip_RgbByteOrder(dest_scan, src_scan, width,
-                                                     m_BlendType, dest_Bpp,
-                                                     src_Bpp, clip_scan);
+        CompositeRow_Rgb2Rgb_Blend_Clip_RgbByteOrder(
+            dest_scan, src_scan.data(), width, m_BlendType, dest_Bpp, src_Bpp,
+            clip_scan);
         break;
       case 13:
         CompositeRow_Rgb2Argb_NoBlend_Clip_RgbByteOrder(
-            dest_scan, src_scan, width, src_Bpp, clip_scan);
+            dest_scan, src_scan.data(), width, src_Bpp, clip_scan);
         break;
       case 15:
         CompositeRow_Rgb2Rgb_NoBlend_Clip_RgbByteOrder(
-            dest_scan, src_scan, width, dest_Bpp, src_Bpp, clip_scan);
+            dest_scan, src_scan.data(), width, dest_Bpp, src_Bpp, clip_scan);
         break;
     }
     return;
@@ -2838,30 +2839,32 @@
   if (m_DestFormat == FXDIB_Format::k8bppMask) {
     if (GetIsAlphaFromFormat(m_SrcFormat)) {
       if (m_SrcFormat == FXDIB_Format::kArgb) {
-        CompositeRow_AlphaToMask(dest_scan, src_scan, width, clip_scan, 4);
+        CompositeRow_AlphaToMask(dest_scan, src_scan.data(), width, clip_scan,
+                                 4);
       } else {
-        CompositeRow_AlphaToMask(dest_scan, src_extra_alpha, width, clip_scan,
-                                 1);
+        CompositeRow_AlphaToMask(dest_scan, src_extra_alpha.data(), width,
+                                 clip_scan, 1);
       }
     } else {
-      CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan);
+      CompositeRow_Rgb2Mask(dest_scan, src_scan.data(), width, clip_scan);
     }
   } else if (GetBppFromFormat(m_DestFormat) == 8) {
     if (GetIsAlphaFromFormat(m_SrcFormat)) {
       if (GetIsAlphaFromFormat(m_DestFormat)) {
-        CompositeRow_Argb2Graya(dest_scan, src_scan, width, m_BlendType,
-                                clip_scan, src_extra_alpha, dst_extra_alpha);
+        CompositeRow_Argb2Graya(dest_scan, src_scan.data(), width, m_BlendType,
+                                clip_scan, src_extra_alpha.data(),
+                                dst_extra_alpha.data());
       } else {
-        CompositeRow_Argb2Gray(dest_scan, src_scan, width, m_BlendType,
-                               clip_scan, src_extra_alpha);
+        CompositeRow_Argb2Gray(dest_scan, src_scan.data(), width, m_BlendType,
+                               clip_scan, src_extra_alpha.data());
       }
     } else {
       if (GetIsAlphaFromFormat(m_DestFormat)) {
-        CompositeRow_Rgb2Graya(dest_scan, src_scan, src_Bpp, width, m_BlendType,
-                               clip_scan, dst_extra_alpha);
+        CompositeRow_Rgb2Graya(dest_scan, src_scan.data(), src_Bpp, width,
+                               m_BlendType, clip_scan, dst_extra_alpha.data());
       } else {
-        CompositeRow_Rgb2Gray(dest_scan, src_scan, src_Bpp, width, m_BlendType,
-                              clip_scan);
+        CompositeRow_Rgb2Gray(dest_scan, src_scan.data(), src_Bpp, width,
+                              m_BlendType, clip_scan);
       }
     }
   } else {
@@ -2870,51 +2873,57 @@
       case 4:
       case 8:
       case 4 + 8: {
-        CompositeRow_Argb2Argb(dest_scan, src_scan, width, m_BlendType,
-                               clip_scan, dst_extra_alpha, src_extra_alpha);
+        CompositeRow_Argb2Argb(dest_scan, src_scan.data(), width, m_BlendType,
+                               clip_scan, dst_extra_alpha.data(),
+                               src_extra_alpha.data());
       } break;
       case 1:
-        CompositeRow_Rgb2Argb_Blend_NoClip(
-            dest_scan, src_scan, width, m_BlendType, src_Bpp, dst_extra_alpha);
+        CompositeRow_Rgb2Argb_Blend_NoClip(dest_scan, src_scan.data(), width,
+                                           m_BlendType, src_Bpp,
+                                           dst_extra_alpha.data());
         break;
       case 1 + 8:
-        CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_scan, width,
+        CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_scan.data(), width,
                                          m_BlendType, src_Bpp, clip_scan,
-                                         dst_extra_alpha);
+                                         dst_extra_alpha.data());
         break;
       case 1 + 4:
-        CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_scan, width,
-                                             src_Bpp, dst_extra_alpha);
+        CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_scan.data(), width,
+                                             src_Bpp, dst_extra_alpha.data());
         break;
       case 1 + 4 + 8:
-        CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_scan, width, src_Bpp,
-                                           clip_scan, dst_extra_alpha);
+        CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_scan.data(), width,
+                                           src_Bpp, clip_scan,
+                                           dst_extra_alpha.data());
         break;
       case 2:
       case 2 + 8:
-        CompositeRow_Argb2Rgb_Blend(dest_scan, src_scan, width, m_BlendType,
-                                    dest_Bpp, clip_scan, src_extra_alpha);
+        CompositeRow_Argb2Rgb_Blend(dest_scan, src_scan.data(), width,
+                                    m_BlendType, dest_Bpp, clip_scan,
+                                    src_extra_alpha.data());
         break;
       case 2 + 4:
       case 2 + 4 + 8:
-        CompositeRow_Argb2Rgb_NoBlend(dest_scan, src_scan, width, dest_Bpp,
-                                      clip_scan, src_extra_alpha);
+        CompositeRow_Argb2Rgb_NoBlend(dest_scan, src_scan.data(), width,
+                                      dest_Bpp, clip_scan,
+                                      src_extra_alpha.data());
         break;
       case 1 + 2:
-        CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_scan, width,
+        CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_scan.data(), width,
                                           m_BlendType, dest_Bpp, src_Bpp);
         break;
       case 1 + 2 + 8:
-        CompositeRow_Rgb2Rgb_Blend_Clip(dest_scan, src_scan, width, m_BlendType,
-                                        dest_Bpp, src_Bpp, clip_scan);
+        CompositeRow_Rgb2Rgb_Blend_Clip(dest_scan, src_scan.data(), width,
+                                        m_BlendType, dest_Bpp, src_Bpp,
+                                        clip_scan);
         break;
       case 1 + 2 + 4:
-        CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_scan, width,
+        CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_scan.data(), width,
                                             dest_Bpp, src_Bpp);
         break;
       case 1 + 2 + 4 + 8:
-        CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_scan, width, dest_Bpp,
-                                          src_Bpp, clip_scan);
+        CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_scan.data(), width,
+                                          dest_Bpp, src_Bpp, clip_scan);
         break;
     }
   }
@@ -2922,12 +2931,12 @@
 
 void CFX_ScanlineCompositor::CompositePalBitmapLine(
     uint8_t* dest_scan,
-    const uint8_t* src_scan,
+    pdfium::span<const uint8_t> src_scan,
     int src_left,
     int width,
     const uint8_t* clip_scan,
-    const uint8_t* src_extra_alpha,
-    uint8_t* dst_extra_alpha) {
+    pdfium::span<const uint8_t> src_extra_alpha,
+    pdfium::span<uint8_t> dst_extra_alpha) {
   if (m_bRgbByteOrder) {
     if (m_SrcFormat == FXDIB_Format::k1bppRgb) {
       if (m_DestFormat == FXDIB_Format::k8bppRgb) {
@@ -2935,12 +2944,13 @@
       }
       if (m_DestFormat == FXDIB_Format::kArgb) {
         CompositeRow_1bppRgb2Argb_NoBlend_RgbByteOrder(
-            dest_scan, src_scan, src_left, width,
+            dest_scan, src_scan.data(), src_left, width,
             m_SrcPalette.Get32BitPalette(), clip_scan);
       } else {
         CompositeRow_1bppRgb2Rgb_NoBlend_RgbByteOrder(
-            dest_scan, src_scan, src_left, m_SrcPalette.Get32BitPalette(),
-            width, GetCompsFromFormat(m_DestFormat), clip_scan);
+            dest_scan, src_scan.data(), src_left,
+            m_SrcPalette.Get32BitPalette(), width,
+            GetCompsFromFormat(m_DestFormat), clip_scan);
       }
     } else {
       if (m_DestFormat == FXDIB_Format::k8bppRgb) {
@@ -2948,151 +2958,161 @@
       }
       if (m_DestFormat == FXDIB_Format::kArgb) {
         CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder(
-            dest_scan, src_scan, width, m_SrcPalette.Get32BitPalette().data(),
-            clip_scan);
+            dest_scan, src_scan.data(), width,
+            m_SrcPalette.Get32BitPalette().data(), clip_scan);
       } else {
         CompositeRow_8bppRgb2Rgb_NoBlend_RgbByteOrder(
-            dest_scan, src_scan, m_SrcPalette.Get32BitPalette().data(), width,
-            GetCompsFromFormat(m_DestFormat), clip_scan);
+            dest_scan, src_scan.data(), m_SrcPalette.Get32BitPalette().data(),
+            width, GetCompsFromFormat(m_DestFormat), clip_scan);
       }
     }
     return;
   }
   if (m_DestFormat == FXDIB_Format::k8bppMask) {
-    CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan);
+    CompositeRow_Rgb2Mask(dest_scan, src_scan.data(), width, clip_scan);
     return;
   }
   if (GetBppFromFormat(m_DestFormat) == 8) {
     if (m_iTransparency & 8) {
       if (GetIsAlphaFromFormat(m_DestFormat)) {
-        CompositeRow_1bppPal2Graya(dest_scan, src_scan, src_left,
-                                   m_SrcPalette.Get8BitPalette(), width,
-                                   m_BlendType, clip_scan, dst_extra_alpha);
+        CompositeRow_1bppPal2Graya(
+            dest_scan, src_scan.data(), src_left, m_SrcPalette.Get8BitPalette(),
+            width, m_BlendType, clip_scan, dst_extra_alpha.data());
       } else {
-        CompositeRow_1bppPal2Gray(dest_scan, src_scan, src_left,
+        CompositeRow_1bppPal2Gray(dest_scan, src_scan.data(), src_left,
                                   m_SrcPalette.Get8BitPalette(), width,
                                   m_BlendType, clip_scan);
       }
     } else {
       if (GetIsAlphaFromFormat(m_DestFormat)) {
         CompositeRow_8bppPal2Graya(
-            dest_scan, src_scan, m_SrcPalette.Get8BitPalette().data(), width,
-            m_BlendType, clip_scan, dst_extra_alpha, src_extra_alpha);
+            dest_scan, src_scan.data(), m_SrcPalette.Get8BitPalette().data(),
+            width, m_BlendType, clip_scan, dst_extra_alpha.data(),
+            src_extra_alpha.data());
       } else {
-        CompositeRow_8bppPal2Gray(dest_scan, src_scan,
-                                  m_SrcPalette.Get8BitPalette().data(), width,
-                                  m_BlendType, clip_scan, src_extra_alpha);
+        CompositeRow_8bppPal2Gray(
+            dest_scan, src_scan.data(), m_SrcPalette.Get8BitPalette().data(),
+            width, m_BlendType, clip_scan, src_extra_alpha.data());
       }
     }
   } else {
     switch (m_iTransparency) {
       case 1 + 2:
-        CompositeRow_8bppRgb2Argb_NoBlend(dest_scan, src_scan, width,
+        CompositeRow_8bppRgb2Argb_NoBlend(dest_scan, src_scan.data(), width,
                                           m_SrcPalette.Get32BitPalette().data(),
-                                          clip_scan, src_extra_alpha);
+                                          clip_scan, src_extra_alpha.data());
         break;
       case 1 + 2 + 8:
-        CompositeRow_1bppRgb2Argb_NoBlend(dest_scan, src_scan, src_left, width,
-                                          m_SrcPalette.Get32BitPalette(),
+        CompositeRow_1bppRgb2Argb_NoBlend(dest_scan, src_scan.data(), src_left,
+                                          width, m_SrcPalette.Get32BitPalette(),
                                           clip_scan);
         break;
       case 0:
         CompositeRow_8bppRgb2Rgb_NoBlend(
-            dest_scan, src_scan, m_SrcPalette.Get32BitPalette().data(), width,
-            GetCompsFromFormat(m_DestFormat), clip_scan, src_extra_alpha);
+            dest_scan, src_scan.data(), m_SrcPalette.Get32BitPalette().data(),
+            width, GetCompsFromFormat(m_DestFormat), clip_scan,
+            src_extra_alpha.data());
         break;
       case 0 + 8:
-        CompositeRow_1bppRgb2Rgb_NoBlend(
-            dest_scan, src_scan, src_left, m_SrcPalette.Get32BitPalette(),
-            width, GetCompsFromFormat(m_DestFormat), clip_scan);
+        CompositeRow_1bppRgb2Rgb_NoBlend(dest_scan, src_scan.data(), src_left,
+                                         m_SrcPalette.Get32BitPalette(), width,
+                                         GetCompsFromFormat(m_DestFormat),
+                                         clip_scan);
         break;
       case 0 + 2:
         CompositeRow_8bppRgb2Rgb_NoBlend(
-            dest_scan, src_scan, m_SrcPalette.Get32BitPalette().data(), width,
-            GetCompsFromFormat(m_DestFormat), clip_scan, src_extra_alpha);
+            dest_scan, src_scan.data(), m_SrcPalette.Get32BitPalette().data(),
+            width, GetCompsFromFormat(m_DestFormat), clip_scan,
+            src_extra_alpha.data());
         break;
       case 0 + 2 + 8:
-        CompositeRow_1bppRgb2Rgba_NoBlend(dest_scan, src_scan, src_left, width,
-                                          m_SrcPalette.Get32BitPalette(),
-                                          clip_scan, dst_extra_alpha);
+        CompositeRow_1bppRgb2Rgba_NoBlend(dest_scan, src_scan.data(), src_left,
+                                          width, m_SrcPalette.Get32BitPalette(),
+                                          clip_scan, dst_extra_alpha.data());
         break;
     }
   }
 }
 
-void CFX_ScanlineCompositor::CompositeByteMaskLine(uint8_t* dest_scan,
-                                                   const uint8_t* src_scan,
-                                                   int width,
-                                                   const uint8_t* clip_scan,
-                                                   uint8_t* dst_extra_alpha) {
+void CFX_ScanlineCompositor::CompositeByteMaskLine(
+    uint8_t* dest_scan,
+    pdfium::span<const uint8_t> src_scan,
+    int width,
+    const uint8_t* clip_scan,
+    pdfium::span<uint8_t> dst_extra_alpha) {
   if (m_DestFormat == FXDIB_Format::k8bppMask) {
-    CompositeRow_ByteMask2Mask(dest_scan, src_scan, m_MaskAlpha, width,
+    CompositeRow_ByteMask2Mask(dest_scan, src_scan.data(), m_MaskAlpha, width,
                                clip_scan);
   } else if (GetBppFromFormat(m_DestFormat) == 8) {
     if (GetIsAlphaFromFormat(m_DestFormat)) {
-      CompositeRow_ByteMask2Graya(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                                  width, clip_scan, dst_extra_alpha);
+      CompositeRow_ByteMask2Graya(dest_scan, src_scan.data(), m_MaskAlpha,
+                                  m_MaskRed, width, clip_scan,
+                                  dst_extra_alpha.data());
     } else {
-      CompositeRow_ByteMask2Gray(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                                 width, clip_scan);
+      CompositeRow_ByteMask2Gray(dest_scan, src_scan.data(), m_MaskAlpha,
+                                 m_MaskRed, width, clip_scan);
     }
   } else if (m_bRgbByteOrder) {
     if (m_DestFormat == FXDIB_Format::kArgb) {
       CompositeRow_ByteMask2Argb_RgbByteOrder(
-          dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
-          width, m_BlendType, clip_scan);
+          dest_scan, src_scan.data(), m_MaskAlpha, m_MaskRed, m_MaskGreen,
+          m_MaskBlue, width, m_BlendType, clip_scan);
     } else {
       CompositeRow_ByteMask2Rgb_RgbByteOrder(
-          dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
-          width, m_BlendType, GetCompsFromFormat(m_DestFormat), clip_scan);
+          dest_scan, src_scan.data(), m_MaskAlpha, m_MaskRed, m_MaskGreen,
+          m_MaskBlue, width, m_BlendType, GetCompsFromFormat(m_DestFormat),
+          clip_scan);
     }
   } else if (m_DestFormat == FXDIB_Format::kArgb) {
-    CompositeRow_ByteMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                               m_MaskGreen, m_MaskBlue, width, m_BlendType,
-                               clip_scan);
+    CompositeRow_ByteMask2Argb(dest_scan, src_scan.data(), m_MaskAlpha,
+                               m_MaskRed, m_MaskGreen, m_MaskBlue, width,
+                               m_BlendType, clip_scan);
   } else if (m_DestFormat == FXDIB_Format::kRgb ||
              m_DestFormat == FXDIB_Format::kRgb32) {
-    CompositeRow_ByteMask2Rgb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                              m_MaskGreen, m_MaskBlue, width, m_BlendType,
-                              GetCompsFromFormat(m_DestFormat), clip_scan);
+    CompositeRow_ByteMask2Rgb(dest_scan, src_scan.data(), m_MaskAlpha,
+                              m_MaskRed, m_MaskGreen, m_MaskBlue, width,
+                              m_BlendType, GetCompsFromFormat(m_DestFormat),
+                              clip_scan);
   }
 }
 
-void CFX_ScanlineCompositor::CompositeBitMaskLine(uint8_t* dest_scan,
-                                                  const uint8_t* src_scan,
-                                                  int src_left,
-                                                  int width,
-                                                  const uint8_t* clip_scan,
-                                                  uint8_t* dst_extra_alpha) {
+void CFX_ScanlineCompositor::CompositeBitMaskLine(
+    uint8_t* dest_scan,
+    pdfium::span<const uint8_t> src_scan,
+    int src_left,
+    int width,
+    const uint8_t* clip_scan,
+    pdfium::span<uint8_t> dst_extra_alpha) {
   if (m_DestFormat == FXDIB_Format::k8bppMask) {
-    CompositeRow_BitMask2Mask(dest_scan, src_scan, m_MaskAlpha, src_left, width,
-                              clip_scan);
+    CompositeRow_BitMask2Mask(dest_scan, src_scan.data(), m_MaskAlpha, src_left,
+                              width, clip_scan);
   } else if (GetBppFromFormat(m_DestFormat) == 8) {
     if (GetIsAlphaFromFormat(m_DestFormat)) {
-      CompositeRow_BitMask2Graya(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                                 src_left, width, clip_scan, dst_extra_alpha);
+      CompositeRow_BitMask2Graya(dest_scan, src_scan.data(), m_MaskAlpha,
+                                 m_MaskRed, src_left, width, clip_scan,
+                                 dst_extra_alpha.data());
     } else {
-      CompositeRow_BitMask2Gray(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                                src_left, width, clip_scan);
+      CompositeRow_BitMask2Gray(dest_scan, src_scan.data(), m_MaskAlpha,
+                                m_MaskRed, src_left, width, clip_scan);
     }
   } else if (m_bRgbByteOrder) {
     if (m_DestFormat == FXDIB_Format::kArgb) {
       CompositeRow_BitMask2Argb_RgbByteOrder(
-          dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
-          src_left, width, m_BlendType, clip_scan);
+          dest_scan, src_scan.data(), m_MaskAlpha, m_MaskRed, m_MaskGreen,
+          m_MaskBlue, src_left, width, m_BlendType, clip_scan);
     } else {
       CompositeRow_BitMask2Rgb_RgbByteOrder(
-          dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
-          src_left, width, m_BlendType, GetCompsFromFormat(m_DestFormat),
-          clip_scan);
+          dest_scan, src_scan.data(), m_MaskAlpha, m_MaskRed, m_MaskGreen,
+          m_MaskBlue, src_left, width, m_BlendType,
+          GetCompsFromFormat(m_DestFormat), clip_scan);
     }
   } else if (m_DestFormat == FXDIB_Format::kArgb) {
-    CompositeRow_BitMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                              m_MaskGreen, m_MaskBlue, src_left, width,
-                              m_BlendType, clip_scan);
+    CompositeRow_BitMask2Argb(dest_scan, src_scan.data(), m_MaskAlpha,
+                              m_MaskRed, m_MaskGreen, m_MaskBlue, src_left,
+                              width, m_BlendType, clip_scan);
   } else if (m_DestFormat == FXDIB_Format::kRgb ||
              m_DestFormat == FXDIB_Format::kRgb32) {
-    CompositeRow_BitMask2Rgb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
+    CompositeRow_BitMask2Rgb(dest_scan, src_scan.data(), m_MaskAlpha, m_MaskRed,
                              m_MaskGreen, m_MaskBlue, src_left, width,
                              m_BlendType, GetCompsFromFormat(m_DestFormat),
                              clip_scan);
diff --git a/core/fxge/dib/cfx_scanlinecompositor.h b/core/fxge/dib/cfx_scanlinecompositor.h
index 2cb9604..0017f1c 100644
--- a/core/fxge/dib/cfx_scanlinecompositor.h
+++ b/core/fxge/dib/cfx_scanlinecompositor.h
@@ -28,32 +28,32 @@
             bool bRgbByteOrder);
 
   void CompositeRgbBitmapLine(uint8_t* dest_scan,
-                              const uint8_t* src_scan,
+                              pdfium::span<const uint8_t> src_scan,
                               int width,
                               const uint8_t* clip_scan,
-                              const uint8_t* src_extra_alpha,
-                              uint8_t* dst_extra_alpha);
+                              pdfium::span<const uint8_t> src_extra_alpha,
+                              pdfium::span<uint8_t> dst_extra_alpha);
 
   void CompositePalBitmapLine(uint8_t* dest_scan,
-                              const uint8_t* src_scan,
+                              pdfium::span<const uint8_t> src_scan,
                               int src_left,
                               int width,
                               const uint8_t* clip_scan,
-                              const uint8_t* src_extra_alpha,
-                              uint8_t* dst_extra_alpha);
+                              pdfium::span<const uint8_t> src_extra_alpha,
+                              pdfium::span<uint8_t> dst_extra_alpha);
 
   void CompositeByteMaskLine(uint8_t* dest_scan,
-                             const uint8_t* src_scan,
+                             pdfium::span<const uint8_t> src_scan,
                              int width,
                              const uint8_t* clip_scan,
-                             uint8_t* dst_extra_alpha);
+                             pdfium::span<uint8_t> dst_extra_alpha);
 
   void CompositeBitMaskLine(uint8_t* dest_scan,
-                            const uint8_t* src_scan,
+                            pdfium::span<const uint8_t> src_scan,
                             int src_left,
                             int width,
                             const uint8_t* clip_scan,
-                            uint8_t* dst_extra_alpha);
+                            pdfium::span<uint8_t> dst_extra_alpha);
 
  private:
   class Palette {
diff --git a/core/fxge/dib/cstretchengine.cpp b/core/fxge/dib/cstretchengine.cpp
index db4830c..3c073bd 100644
--- a/core/fxge/dib/cstretchengine.cpp
+++ b/core/fxge/dib/cstretchengine.cpp
@@ -588,7 +588,7 @@
         break;
       }
     }
-    m_pDestBitmap->ComposeScanline(row - m_DestClip.top, m_DestScanline.data(),
-                                   m_DestMaskScanline.data());
+    m_pDestBitmap->ComposeScanline(row - m_DestClip.top, m_DestScanline,
+                                   m_DestMaskScanline);
   }
 }
diff --git a/core/fxge/dib/scanlinecomposer_iface.h b/core/fxge/dib/scanlinecomposer_iface.h
index 6275fe5..8325c58 100644
--- a/core/fxge/dib/scanlinecomposer_iface.h
+++ b/core/fxge/dib/scanlinecomposer_iface.h
@@ -14,9 +14,10 @@
  public:
   virtual ~ScanlineComposerIface() = default;
 
-  virtual void ComposeScanline(int line,
-                               const uint8_t* scanline,
-                               const uint8_t* scan_extra_alpha) = 0;
+  virtual void ComposeScanline(
+      int line,
+      pdfium::span<const uint8_t> scanline,
+      pdfium::span<const uint8_t> scan_extra_alpha) = 0;
 
   virtual bool SetInfo(int width,
                        int height,