diff --git a/core/fxcodec/BUILD.gn b/core/fxcodec/BUILD.gn
index 5d49f82..0617ef8 100644
--- a/core/fxcodec/BUILD.gn
+++ b/core/fxcodec/BUILD.gn
@@ -9,6 +9,7 @@
 jumbo_source_set("fxcodec") {
   sources = [
     "JBig2_DocumentContext.h",
+    "codec/ccodec_basicmodule.cpp",
     "codec/ccodec_basicmodule.h",
     "codec/ccodec_faxmodule.cpp",
     "codec/ccodec_faxmodule.h",
diff --git a/core/fxcodec/codec/ccodec_basicmodule.cpp b/core/fxcodec/codec/ccodec_basicmodule.cpp
new file mode 100644
index 0000000..ff3824d
--- /dev/null
+++ b/core/fxcodec/codec/ccodec_basicmodule.cpp
@@ -0,0 +1,372 @@
+// Copyright 2019 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "core/fxcodec/codec/ccodec_basicmodule.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "core/fxcodec/codec/ccodec_scanlinedecoder.h"
+#include "third_party/base/ptr_util.h"
+
+namespace {
+
+class CCodec_RLScanlineDecoder final : public CCodec_ScanlineDecoder {
+ public:
+  CCodec_RLScanlineDecoder();
+  ~CCodec_RLScanlineDecoder() override;
+
+  bool Create(pdfium::span<const uint8_t> src_buf,
+              int width,
+              int height,
+              int nComps,
+              int bpc);
+
+  // CCodec_ScanlineDecoder
+  bool v_Rewind() override;
+  uint8_t* v_GetNextLine() override;
+  uint32_t GetSrcOffset() override { return m_SrcOffset; }
+
+ private:
+  bool CheckDestSize();
+  void GetNextOperator();
+  void UpdateOperator(uint8_t used_bytes);
+
+  std::unique_ptr<uint8_t, FxFreeDeleter> m_pScanline;
+  pdfium::span<const uint8_t> m_SrcBuf;
+  size_t m_dwLineBytes = 0;
+  size_t m_SrcOffset = 0;
+  bool m_bEOD = false;
+  uint8_t m_Operator = 0;
+};
+
+CCodec_RLScanlineDecoder::CCodec_RLScanlineDecoder() = default;
+
+CCodec_RLScanlineDecoder::~CCodec_RLScanlineDecoder() = default;
+
+bool CCodec_RLScanlineDecoder::CheckDestSize() {
+  size_t i = 0;
+  uint32_t old_size = 0;
+  uint32_t dest_size = 0;
+  while (i < m_SrcBuf.size()) {
+    if (m_SrcBuf[i] < 128) {
+      old_size = dest_size;
+      dest_size += m_SrcBuf[i] + 1;
+      if (dest_size < old_size) {
+        return false;
+      }
+      i += m_SrcBuf[i] + 2;
+    } else if (m_SrcBuf[i] > 128) {
+      old_size = dest_size;
+      dest_size += 257 - m_SrcBuf[i];
+      if (dest_size < old_size) {
+        return false;
+      }
+      i += 2;
+    } else {
+      break;
+    }
+  }
+  if (((uint32_t)m_OrigWidth * m_nComps * m_bpc * m_OrigHeight + 7) / 8 >
+      dest_size) {
+    return false;
+  }
+  return true;
+}
+
+bool CCodec_RLScanlineDecoder::Create(pdfium::span<const uint8_t> src_buf,
+                                      int width,
+                                      int height,
+                                      int nComps,
+                                      int bpc) {
+  m_SrcBuf = src_buf;
+  m_OutputWidth = m_OrigWidth = width;
+  m_OutputHeight = m_OrigHeight = height;
+  m_nComps = nComps;
+  m_bpc = bpc;
+  // Aligning the pitch to 4 bytes requires an integer overflow check.
+  FX_SAFE_UINT32 pitch = width;
+  pitch *= nComps;
+  pitch *= bpc;
+  pitch += 31;
+  pitch /= 32;
+  pitch *= 4;
+  if (!pitch.IsValid()) {
+    return false;
+  }
+  m_Pitch = pitch.ValueOrDie();
+  // Overflow should already have been checked before this is called.
+  m_dwLineBytes = (static_cast<uint32_t>(width) * nComps * bpc + 7) / 8;
+  m_pScanline.reset(FX_Alloc(uint8_t, m_Pitch));
+  return CheckDestSize();
+}
+
+bool CCodec_RLScanlineDecoder::v_Rewind() {
+  memset(m_pScanline.get(), 0, m_Pitch);
+  m_SrcOffset = 0;
+  m_bEOD = false;
+  m_Operator = 0;
+  return true;
+}
+
+uint8_t* CCodec_RLScanlineDecoder::v_GetNextLine() {
+  if (m_SrcOffset == 0) {
+    GetNextOperator();
+  } else if (m_bEOD) {
+    return nullptr;
+  }
+  memset(m_pScanline.get(), 0, m_Pitch);
+  uint32_t col_pos = 0;
+  bool eol = false;
+  while (m_SrcOffset < m_SrcBuf.size() && !eol) {
+    if (m_Operator < 128) {
+      uint32_t copy_len = m_Operator + 1;
+      if (col_pos + copy_len >= m_dwLineBytes) {
+        copy_len = m_dwLineBytes - col_pos;
+        eol = true;
+      }
+      if (copy_len >= m_SrcBuf.size() - m_SrcOffset) {
+        copy_len = m_SrcBuf.size() - m_SrcOffset;
+        m_bEOD = true;
+      }
+      auto copy_span = m_SrcBuf.subspan(m_SrcOffset, copy_len);
+      memcpy(m_pScanline.get() + col_pos, copy_span.data(), copy_span.size());
+      col_pos += copy_len;
+      UpdateOperator((uint8_t)copy_len);
+    } else if (m_Operator > 128) {
+      int fill = 0;
+      if (m_SrcOffset - 1 < m_SrcBuf.size() - 1) {
+        fill = m_SrcBuf[m_SrcOffset];
+      }
+      uint32_t duplicate_len = 257 - m_Operator;
+      if (col_pos + duplicate_len >= m_dwLineBytes) {
+        duplicate_len = m_dwLineBytes - col_pos;
+        eol = true;
+      }
+      memset(m_pScanline.get() + col_pos, fill, duplicate_len);
+      col_pos += duplicate_len;
+      UpdateOperator((uint8_t)duplicate_len);
+    } else {
+      m_bEOD = true;
+      break;
+    }
+  }
+  return m_pScanline.get();
+}
+
+void CCodec_RLScanlineDecoder::GetNextOperator() {
+  if (m_SrcOffset >= m_SrcBuf.size()) {
+    m_Operator = 128;
+    return;
+  }
+  m_Operator = m_SrcBuf[m_SrcOffset];
+  m_SrcOffset++;
+}
+void CCodec_RLScanlineDecoder::UpdateOperator(uint8_t used_bytes) {
+  if (used_bytes == 0) {
+    return;
+  }
+  if (m_Operator < 128) {
+    ASSERT((uint32_t)m_Operator + 1 >= used_bytes);
+    if (used_bytes == m_Operator + 1) {
+      m_SrcOffset += used_bytes;
+      GetNextOperator();
+      return;
+    }
+    m_Operator -= used_bytes;
+    m_SrcOffset += used_bytes;
+    if (m_SrcOffset >= m_SrcBuf.size()) {
+      m_Operator = 128;
+    }
+    return;
+  }
+  uint8_t count = 257 - m_Operator;
+  ASSERT((uint32_t)count >= used_bytes);
+  if (used_bytes == count) {
+    m_SrcOffset++;
+    GetNextOperator();
+    return;
+  }
+  count -= used_bytes;
+  m_Operator = 257 - count;
+}
+
+}  // namespace
+
+// static
+std::unique_ptr<CCodec_ScanlineDecoder>
+CCodec_BasicModule::CreateRunLengthDecoder(pdfium::span<const uint8_t> src_buf,
+                                           int width,
+                                           int height,
+                                           int nComps,
+                                           int bpc) {
+  auto pDecoder = pdfium::MakeUnique<CCodec_RLScanlineDecoder>();
+  if (!pDecoder->Create(src_buf, width, height, nComps, bpc))
+    return nullptr;
+
+  return std::move(pDecoder);
+}
+
+// static
+bool CCodec_BasicModule::RunLengthEncode(
+    pdfium::span<const uint8_t> src_span,
+    std::unique_ptr<uint8_t, FxFreeDeleter>* dest_buf,
+    uint32_t* dest_size) {
+  // Check inputs
+  if (src_span.empty() || !dest_buf || !dest_size)
+    return false;
+
+  // Edge case
+  if (src_span.size() == 1) {
+    *dest_size = 3;
+    dest_buf->reset(FX_Alloc(uint8_t, *dest_size));
+    auto dest_buf_span = pdfium::make_span(dest_buf->get(), *dest_size);
+    dest_buf_span[0] = 0;
+    dest_buf_span[1] = src_span[0];
+    dest_buf_span[2] = 128;
+    return true;
+  }
+
+  // Worst case: 1 nonmatch, 2 match, 1 nonmatch, 2 match, etc. This becomes
+  // 4 output chars for every 3 input, plus up to 4 more for the 1-2 chars
+  // rounded off plus the terminating character.
+  FX_SAFE_SIZE_T estimated_size = src_span.size();
+  estimated_size += 2;
+  estimated_size /= 3;
+  estimated_size *= 4;
+  estimated_size += 1;
+  dest_buf->reset(FX_Alloc(uint8_t, estimated_size.ValueOrDie()));
+
+  // Set up pointers.
+  uint8_t* out = dest_buf->get();
+  uint32_t run_start = 0;
+  uint32_t run_end = 1;
+  uint8_t x = src_span[run_start];
+  uint8_t y = src_span[run_end];
+  while (run_end < src_span.size()) {
+    size_t max_len = std::min<size_t>(128, src_span.size() - run_start);
+    while (x == y && (run_end - run_start < max_len - 1))
+      y = src_span[++run_end];
+
+    // Reached end with matched run. Update variables to expected values.
+    if (x == y) {
+      run_end++;
+      if (run_end < src_span.size())
+        y = src_span[run_end];
+    }
+    if (run_end - run_start > 1) {  // Matched run but not at end of input.
+      out[0] = 257 - (run_end - run_start);
+      out[1] = x;
+      x = y;
+      run_start = run_end;
+      run_end++;
+      if (run_end < src_span.size())
+        y = src_span[run_end];
+      out += 2;
+      continue;
+    }
+    // Mismatched run
+    while (x != y && run_end <= run_start + max_len) {
+      out[run_end - run_start] = x;
+      x = y;
+      run_end++;
+      if (run_end == src_span.size()) {
+        if (run_end <= run_start + max_len) {
+          out[run_end - run_start] = x;
+          run_end++;
+        }
+        break;
+      }
+      y = src_span[run_end];
+    }
+    out[0] = run_end - run_start - 2;
+    out += run_end - run_start;
+    run_start = run_end - 1;
+  }
+  if (run_start < src_span.size()) {  // 1 leftover character
+    out[0] = 0;
+    out[1] = x;
+    out += 2;
+  }
+  *out = 128;
+  *dest_size = out + 1 - dest_buf->get();
+  return true;
+}
+
+// static
+bool CCodec_BasicModule::A85Encode(
+    pdfium::span<const uint8_t> src_span,
+    std::unique_ptr<uint8_t, FxFreeDeleter>* dest_buf,
+    uint32_t* dest_size) {
+  // Check inputs.
+  if (!dest_buf || !dest_size)
+    return false;
+
+  if (src_span.empty()) {
+    *dest_size = 0;
+    return false;
+  }
+
+  // Worst case: 5 output for each 4 input (plus up to 4 from leftover), plus
+  // 2 character new lines each 75 output chars plus 2 termination chars. May
+  // have fewer if there are special "z" chars.
+  FX_SAFE_SIZE_T estimated_size = src_span.size();
+  estimated_size /= 4;
+  estimated_size *= 5;
+  estimated_size += 4;
+  estimated_size += src_span.size() / 30;
+  estimated_size += 2;
+  dest_buf->reset(FX_Alloc(uint8_t, estimated_size.ValueOrDie()));
+
+  // Set up pointers.
+  uint8_t* out = dest_buf->get();
+  uint32_t pos = 0;
+  uint32_t line_length = 0;
+  while (src_span.size() >= 4 && pos < src_span.size() - 3) {
+    uint32_t val = ((uint32_t)(src_span[pos]) << 24) +
+                   ((uint32_t)(src_span[pos + 1]) << 16) +
+                   ((uint32_t)(src_span[pos + 2]) << 8) +
+                   (uint32_t)(src_span[pos + 3]);
+    pos += 4;
+    if (val == 0) {  // All zero special case
+      *out = 'z';
+      out++;
+      line_length++;
+    } else {  // Compute base 85 characters and add 33.
+      for (int i = 4; i >= 0; i--) {
+        out[i] = (uint8_t)(val % 85) + 33;
+        val = val / 85;
+      }
+      out += 5;
+      line_length += 5;
+    }
+    if (line_length >= 75) {  // Add a return.
+      *out++ = '\r';
+      *out++ = '\n';
+      line_length = 0;
+    }
+  }
+  if (pos < src_span.size()) {  // Leftover bytes
+    uint32_t val = 0;
+    int count = 0;
+    while (pos < src_span.size()) {
+      val += (uint32_t)(src_span[pos]) << (8 * (3 - count));
+      count++;
+      pos++;
+    }
+    for (int i = 4; i >= 0; i--) {
+      if (i <= count)
+        out[i] = (uint8_t)(val % 85) + 33;
+      val = val / 85;
+    }
+    out += count + 1;
+  }
+
+  // Terminating characters.
+  out[0] = '~';
+  out[1] = '>';
+  out += 2;
+  *dest_size = out - dest_buf->get();
+  return true;
+}
diff --git a/core/fxcodec/codec/ccodec_basicmodule.h b/core/fxcodec/codec/ccodec_basicmodule.h
index 72dd016..8f55901 100644
--- a/core/fxcodec/codec/ccodec_basicmodule.h
+++ b/core/fxcodec/codec/ccodec_basicmodule.h
@@ -17,20 +17,24 @@
 
 class CCodec_BasicModule {
  public:
-  std::unique_ptr<CCodec_ScanlineDecoder> CreateRunLengthDecoder(
+  static std::unique_ptr<CCodec_ScanlineDecoder> CreateRunLengthDecoder(
       pdfium::span<const uint8_t> src_buf,
       int width,
       int height,
       int nComps,
       int bpc);
 
-  bool RunLengthEncode(pdfium::span<const uint8_t> src_buf,
-                       std::unique_ptr<uint8_t, FxFreeDeleter>* dest_buf,
-                       uint32_t* dest_size);
+  static bool RunLengthEncode(pdfium::span<const uint8_t> src_buf,
+                              std::unique_ptr<uint8_t, FxFreeDeleter>* dest_buf,
+                              uint32_t* dest_size);
 
-  bool A85Encode(pdfium::span<const uint8_t> src_buf,
-                 std::unique_ptr<uint8_t, FxFreeDeleter>* dest_buf,
-                 uint32_t* dest_size);
+  static bool A85Encode(pdfium::span<const uint8_t> src_buf,
+                        std::unique_ptr<uint8_t, FxFreeDeleter>* dest_buf,
+                        uint32_t* dest_size);
+
+  CCodec_BasicModule() = delete;
+  CCodec_BasicModule(const CCodec_BasicModule&) = delete;
+  CCodec_BasicModule& operator=(const CCodec_BasicModule&) = delete;
 };
 
 #endif  // CORE_FXCODEC_CODEC_CCODEC_BASICMODULE_H_
diff --git a/core/fxcodec/codec/fx_codec.cpp b/core/fxcodec/codec/fx_codec.cpp
index 0a34a1d..e2ba733 100644
--- a/core/fxcodec/codec/fx_codec.cpp
+++ b/core/fxcodec/codec/fx_codec.cpp
@@ -11,13 +11,11 @@
 #include <memory>
 #include <utility>
 
-#include "core/fxcodec/codec/ccodec_basicmodule.h"
 #include "core/fxcodec/codec/ccodec_faxmodule.h"
 #include "core/fxcodec/codec/ccodec_iccmodule.h"
 #include "core/fxcodec/codec/ccodec_jbig2module.h"
 #include "core/fxcodec/codec/ccodec_jpegmodule.h"
 #include "core/fxcodec/codec/ccodec_jpxmodule.h"
-#include "core/fxcodec/codec/ccodec_scanlinedecoder.h"
 #include "core/fxcodec/codec/codec_int.h"
 #include "core/fxcrt/fx_extension.h"
 #include "core/fxcrt/fx_safe_types.h"
@@ -25,8 +23,7 @@
 #include "third_party/base/ptr_util.h"
 
 CCodec_ModuleMgr::CCodec_ModuleMgr()
-    : m_pBasicModule(pdfium::MakeUnique<CCodec_BasicModule>()),
-      m_pFaxModule(pdfium::MakeUnique<CCodec_FaxModule>()),
+    : m_pFaxModule(pdfium::MakeUnique<CCodec_FaxModule>()),
       m_pJpegModule(pdfium::MakeUnique<CCodec_JpegModule>()),
       m_pJpxModule(pdfium::MakeUnique<CCodec_JpxModule>()),
       m_pJbig2Module(pdfium::MakeUnique<CCodec_Jbig2Module>()),
@@ -34,167 +31,6 @@
 
 CCodec_ModuleMgr::~CCodec_ModuleMgr() = default;
 
-bool CCodec_BasicModule::RunLengthEncode(
-    pdfium::span<const uint8_t> src_span,
-    std::unique_ptr<uint8_t, FxFreeDeleter>* dest_buf,
-    uint32_t* dest_size) {
-  // Check inputs
-  if (src_span.empty() || !dest_buf || !dest_size)
-    return false;
-
-  // Edge case
-  if (src_span.size() == 1) {
-    *dest_size = 3;
-    dest_buf->reset(FX_Alloc(uint8_t, *dest_size));
-    auto dest_buf_span = pdfium::make_span(dest_buf->get(), *dest_size);
-    dest_buf_span[0] = 0;
-    dest_buf_span[1] = src_span[0];
-    dest_buf_span[2] = 128;
-    return true;
-  }
-
-  // Worst case: 1 nonmatch, 2 match, 1 nonmatch, 2 match, etc. This becomes
-  // 4 output chars for every 3 input, plus up to 4 more for the 1-2 chars
-  // rounded off plus the terminating character.
-  FX_SAFE_SIZE_T estimated_size = src_span.size();
-  estimated_size += 2;
-  estimated_size /= 3;
-  estimated_size *= 4;
-  estimated_size += 1;
-  dest_buf->reset(FX_Alloc(uint8_t, estimated_size.ValueOrDie()));
-
-  // Set up pointers.
-  uint8_t* out = dest_buf->get();
-  uint32_t run_start = 0;
-  uint32_t run_end = 1;
-  uint8_t x = src_span[run_start];
-  uint8_t y = src_span[run_end];
-  while (run_end < src_span.size()) {
-    size_t max_len = std::min<size_t>(128, src_span.size() - run_start);
-    while (x == y && (run_end - run_start < max_len - 1))
-      y = src_span[++run_end];
-
-    // Reached end with matched run. Update variables to expected values.
-    if (x == y) {
-      run_end++;
-      if (run_end < src_span.size())
-        y = src_span[run_end];
-    }
-    if (run_end - run_start > 1) {  // Matched run but not at end of input.
-      out[0] = 257 - (run_end - run_start);
-      out[1] = x;
-      x = y;
-      run_start = run_end;
-      run_end++;
-      if (run_end < src_span.size())
-        y = src_span[run_end];
-      out += 2;
-      continue;
-    }
-    // Mismatched run
-    while (x != y && run_end <= run_start + max_len) {
-      out[run_end - run_start] = x;
-      x = y;
-      run_end++;
-      if (run_end == src_span.size()) {
-        if (run_end <= run_start + max_len) {
-          out[run_end - run_start] = x;
-          run_end++;
-        }
-        break;
-      }
-      y = src_span[run_end];
-    }
-    out[0] = run_end - run_start - 2;
-    out += run_end - run_start;
-    run_start = run_end - 1;
-  }
-  if (run_start < src_span.size()) {  // 1 leftover character
-    out[0] = 0;
-    out[1] = x;
-    out += 2;
-  }
-  *out = 128;
-  *dest_size = out + 1 - dest_buf->get();
-  return true;
-}
-
-bool CCodec_BasicModule::A85Encode(
-    pdfium::span<const uint8_t> src_span,
-    std::unique_ptr<uint8_t, FxFreeDeleter>* dest_buf,
-    uint32_t* dest_size) {
-  // Check inputs.
-  if (!dest_buf || !dest_size)
-    return false;
-
-  if (src_span.empty()) {
-    *dest_size = 0;
-    return false;
-  }
-
-  // Worst case: 5 output for each 4 input (plus up to 4 from leftover), plus
-  // 2 character new lines each 75 output chars plus 2 termination chars. May
-  // have fewer if there are special "z" chars.
-  FX_SAFE_SIZE_T estimated_size = src_span.size();
-  estimated_size /= 4;
-  estimated_size *= 5;
-  estimated_size += 4;
-  estimated_size += src_span.size() / 30;
-  estimated_size += 2;
-  dest_buf->reset(FX_Alloc(uint8_t, estimated_size.ValueOrDie()));
-
-  // Set up pointers.
-  uint8_t* out = dest_buf->get();
-  uint32_t pos = 0;
-  uint32_t line_length = 0;
-  while (src_span.size() >= 4 && pos < src_span.size() - 3) {
-    uint32_t val = ((uint32_t)(src_span[pos]) << 24) +
-                   ((uint32_t)(src_span[pos + 1]) << 16) +
-                   ((uint32_t)(src_span[pos + 2]) << 8) +
-                   (uint32_t)(src_span[pos + 3]);
-    pos += 4;
-    if (val == 0) {  // All zero special case
-      *out = 'z';
-      out++;
-      line_length++;
-    } else {  // Compute base 85 characters and add 33.
-      for (int i = 4; i >= 0; i--) {
-        out[i] = (uint8_t)(val % 85) + 33;
-        val = val / 85;
-      }
-      out += 5;
-      line_length += 5;
-    }
-    if (line_length >= 75) {  // Add a return.
-      *out++ = '\r';
-      *out++ = '\n';
-      line_length = 0;
-    }
-  }
-  if (pos < src_span.size()) {  // Leftover bytes
-    uint32_t val = 0;
-    int count = 0;
-    while (pos < src_span.size()) {
-      val += (uint32_t)(src_span[pos]) << (8 * (3 - count));
-      count++;
-      pos++;
-    }
-    for (int i = 4; i >= 0; i--) {
-      if (i <= count)
-        out[i] = (uint8_t)(val % 85) + 33;
-      val = val / 85;
-    }
-    out += count + 1;
-  }
-
-  // Terminating characters.
-  out[0] = '~';
-  out[1] = '>';
-  out += 2;
-  *dest_size = out - dest_buf->get();
-  return true;
-}
-
 #ifdef PDF_ENABLE_XFA
 CFX_DIBAttribute::CFX_DIBAttribute() {}
 
@@ -204,199 +40,6 @@
 }
 #endif  // PDF_ENABLE_XFA
 
-class CCodec_RLScanlineDecoder final : public CCodec_ScanlineDecoder {
- public:
-  CCodec_RLScanlineDecoder();
-  ~CCodec_RLScanlineDecoder() override;
-
-  bool Create(pdfium::span<const uint8_t> src_buf,
-              int width,
-              int height,
-              int nComps,
-              int bpc);
-
-  // CCodec_ScanlineDecoder
-  bool v_Rewind() override;
-  uint8_t* v_GetNextLine() override;
-  uint32_t GetSrcOffset() override { return m_SrcOffset; }
-
- private:
-  bool CheckDestSize();
-  void GetNextOperator();
-  void UpdateOperator(uint8_t used_bytes);
-
-  std::unique_ptr<uint8_t, FxFreeDeleter> m_pScanline;
-  pdfium::span<const uint8_t> m_SrcBuf;
-  size_t m_dwLineBytes = 0;
-  size_t m_SrcOffset = 0;
-  bool m_bEOD = false;
-  uint8_t m_Operator = 0;
-};
-
-CCodec_RLScanlineDecoder::CCodec_RLScanlineDecoder() = default;
-
-CCodec_RLScanlineDecoder::~CCodec_RLScanlineDecoder() = default;
-
-bool CCodec_RLScanlineDecoder::CheckDestSize() {
-  size_t i = 0;
-  uint32_t old_size = 0;
-  uint32_t dest_size = 0;
-  while (i < m_SrcBuf.size()) {
-    if (m_SrcBuf[i] < 128) {
-      old_size = dest_size;
-      dest_size += m_SrcBuf[i] + 1;
-      if (dest_size < old_size) {
-        return false;
-      }
-      i += m_SrcBuf[i] + 2;
-    } else if (m_SrcBuf[i] > 128) {
-      old_size = dest_size;
-      dest_size += 257 - m_SrcBuf[i];
-      if (dest_size < old_size) {
-        return false;
-      }
-      i += 2;
-    } else {
-      break;
-    }
-  }
-  if (((uint32_t)m_OrigWidth * m_nComps * m_bpc * m_OrigHeight + 7) / 8 >
-      dest_size) {
-    return false;
-  }
-  return true;
-}
-
-bool CCodec_RLScanlineDecoder::Create(pdfium::span<const uint8_t> src_buf,
-                                      int width,
-                                      int height,
-                                      int nComps,
-                                      int bpc) {
-  m_SrcBuf = src_buf;
-  m_OutputWidth = m_OrigWidth = width;
-  m_OutputHeight = m_OrigHeight = height;
-  m_nComps = nComps;
-  m_bpc = bpc;
-  // Aligning the pitch to 4 bytes requires an integer overflow check.
-  FX_SAFE_UINT32 pitch = width;
-  pitch *= nComps;
-  pitch *= bpc;
-  pitch += 31;
-  pitch /= 32;
-  pitch *= 4;
-  if (!pitch.IsValid()) {
-    return false;
-  }
-  m_Pitch = pitch.ValueOrDie();
-  // Overflow should already have been checked before this is called.
-  m_dwLineBytes = (static_cast<uint32_t>(width) * nComps * bpc + 7) / 8;
-  m_pScanline.reset(FX_Alloc(uint8_t, m_Pitch));
-  return CheckDestSize();
-}
-
-bool CCodec_RLScanlineDecoder::v_Rewind() {
-  memset(m_pScanline.get(), 0, m_Pitch);
-  m_SrcOffset = 0;
-  m_bEOD = false;
-  m_Operator = 0;
-  return true;
-}
-
-uint8_t* CCodec_RLScanlineDecoder::v_GetNextLine() {
-  if (m_SrcOffset == 0) {
-    GetNextOperator();
-  } else if (m_bEOD) {
-    return nullptr;
-  }
-  memset(m_pScanline.get(), 0, m_Pitch);
-  uint32_t col_pos = 0;
-  bool eol = false;
-  while (m_SrcOffset < m_SrcBuf.size() && !eol) {
-    if (m_Operator < 128) {
-      uint32_t copy_len = m_Operator + 1;
-      if (col_pos + copy_len >= m_dwLineBytes) {
-        copy_len = m_dwLineBytes - col_pos;
-        eol = true;
-      }
-      if (copy_len >= m_SrcBuf.size() - m_SrcOffset) {
-        copy_len = m_SrcBuf.size() - m_SrcOffset;
-        m_bEOD = true;
-      }
-      auto copy_span = m_SrcBuf.subspan(m_SrcOffset, copy_len);
-      memcpy(m_pScanline.get() + col_pos, copy_span.data(), copy_span.size());
-      col_pos += copy_len;
-      UpdateOperator((uint8_t)copy_len);
-    } else if (m_Operator > 128) {
-      int fill = 0;
-      if (m_SrcOffset - 1 < m_SrcBuf.size() - 1) {
-        fill = m_SrcBuf[m_SrcOffset];
-      }
-      uint32_t duplicate_len = 257 - m_Operator;
-      if (col_pos + duplicate_len >= m_dwLineBytes) {
-        duplicate_len = m_dwLineBytes - col_pos;
-        eol = true;
-      }
-      memset(m_pScanline.get() + col_pos, fill, duplicate_len);
-      col_pos += duplicate_len;
-      UpdateOperator((uint8_t)duplicate_len);
-    } else {
-      m_bEOD = true;
-      break;
-    }
-  }
-  return m_pScanline.get();
-}
-
-void CCodec_RLScanlineDecoder::GetNextOperator() {
-  if (m_SrcOffset >= m_SrcBuf.size()) {
-    m_Operator = 128;
-    return;
-  }
-  m_Operator = m_SrcBuf[m_SrcOffset];
-  m_SrcOffset++;
-}
-void CCodec_RLScanlineDecoder::UpdateOperator(uint8_t used_bytes) {
-  if (used_bytes == 0) {
-    return;
-  }
-  if (m_Operator < 128) {
-    ASSERT((uint32_t)m_Operator + 1 >= used_bytes);
-    if (used_bytes == m_Operator + 1) {
-      m_SrcOffset += used_bytes;
-      GetNextOperator();
-      return;
-    }
-    m_Operator -= used_bytes;
-    m_SrcOffset += used_bytes;
-    if (m_SrcOffset >= m_SrcBuf.size()) {
-      m_Operator = 128;
-    }
-    return;
-  }
-  uint8_t count = 257 - m_Operator;
-  ASSERT((uint32_t)count >= used_bytes);
-  if (used_bytes == count) {
-    m_SrcOffset++;
-    GetNextOperator();
-    return;
-  }
-  count -= used_bytes;
-  m_Operator = 257 - count;
-}
-
-std::unique_ptr<CCodec_ScanlineDecoder>
-CCodec_BasicModule::CreateRunLengthDecoder(pdfium::span<const uint8_t> src_buf,
-                                           int width,
-                                           int height,
-                                           int nComps,
-                                           int bpc) {
-  auto pDecoder = pdfium::MakeUnique<CCodec_RLScanlineDecoder>();
-  if (!pDecoder->Create(src_buf, width, height, nComps, bpc))
-    return nullptr;
-
-  return std::move(pDecoder);
-}
-
 FX_SAFE_UINT32 CalculatePitch8(uint32_t bpc, uint32_t components, int width) {
   FX_SAFE_UINT32 pitch = bpc;
   pitch *= components;
diff --git a/core/fxcodec/codec/fx_codec_a85_unittest.cpp b/core/fxcodec/codec/fx_codec_a85_unittest.cpp
index 1372858..c6eb34d 100644
--- a/core/fxcodec/codec/fx_codec_a85_unittest.cpp
+++ b/core/fxcodec/codec/fx_codec_a85_unittest.cpp
@@ -8,7 +8,6 @@
 #include <memory>
 
 #include "core/fxcodec/codec/ccodec_basicmodule.h"
-#include "core/fxcodec/fx_codec.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 TEST(fxcodec, A85TestBadInputs) {
@@ -16,25 +15,19 @@
   std::unique_ptr<uint8_t, FxFreeDeleter> dest_buf;
   uint32_t dest_size = 0;
 
-  CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule();
-  EXPECT_TRUE(pEncoders);
-
   // Error codes, not segvs, should callers pass us a nullptr pointer.
-  EXPECT_FALSE(pEncoders->A85Encode(src_buf, &dest_buf, nullptr));
-  EXPECT_FALSE(pEncoders->A85Encode(src_buf, nullptr, &dest_size));
-  EXPECT_FALSE(pEncoders->A85Encode({}, &dest_buf, &dest_size));
+  EXPECT_FALSE(CCodec_BasicModule::A85Encode(src_buf, &dest_buf, nullptr));
+  EXPECT_FALSE(CCodec_BasicModule::A85Encode(src_buf, nullptr, &dest_size));
+  EXPECT_FALSE(CCodec_BasicModule::A85Encode({}, &dest_buf, &dest_size));
 }
 
 // No leftover bytes, just translate 2 sets of symbols.
 TEST(fxcodec, A85TestBasic) {
-  CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule();
-  EXPECT_TRUE(pEncoders);
-
   // Make sure really big values don't break.
   const uint8_t src_buf[] = {1, 2, 3, 4, 255, 255, 255, 255};
   std::unique_ptr<uint8_t, FxFreeDeleter> dest_buf;
   uint32_t dest_size = 0;
-  EXPECT_TRUE(pEncoders->A85Encode(src_buf, &dest_buf, &dest_size));
+  EXPECT_TRUE(CCodec_BasicModule::A85Encode(src_buf, &dest_buf, &dest_size));
 
   // Should have 5 chars for each set of 4 and 2 terminators.
   const uint8_t expected_out[] = {33, 60, 78, 63, 43,  115,
@@ -49,16 +42,14 @@
 
 // Leftover bytes.
 TEST(fxcodec, A85TestLeftoverBytes) {
-  CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule();
-  EXPECT_TRUE(pEncoders);
-
   std::unique_ptr<uint8_t, FxFreeDeleter> dest_buf;
   uint32_t dest_size = 0;
 
   {
     // 1 Leftover Byte:
     const uint8_t src_buf_1leftover[] = {1, 2, 3, 4, 255};
-    EXPECT_TRUE(pEncoders->A85Encode(src_buf_1leftover, &dest_buf, &dest_size));
+    EXPECT_TRUE(CCodec_BasicModule::A85Encode(src_buf_1leftover, &dest_buf,
+                                              &dest_size));
 
     // 5 chars for first symbol + 2 + 2 terminators.
     uint8_t expected_out_1leftover[] = {33, 60, 78, 63, 43, 114, 114, 126, 62};
@@ -75,7 +66,8 @@
     const uint8_t src_buf_2leftover[] = {1, 2, 3, 4, 255, 254};
     dest_buf.reset();
     dest_size = 0;
-    EXPECT_TRUE(pEncoders->A85Encode(src_buf_2leftover, &dest_buf, &dest_size));
+    EXPECT_TRUE(CCodec_BasicModule::A85Encode(src_buf_2leftover, &dest_buf,
+                                              &dest_size));
     // 5 chars for first symbol + 3 + 2 terminators.
     const uint8_t expected_out_2leftover[] = {33,  60, 78, 63,  43,
                                               115, 56, 68, 126, 62};
@@ -92,7 +84,8 @@
     const uint8_t src_buf_3leftover[] = {1, 2, 3, 4, 255, 254, 253};
     dest_buf.reset();
     dest_size = 0;
-    EXPECT_TRUE(pEncoders->A85Encode(src_buf_3leftover, &dest_buf, &dest_size));
+    EXPECT_TRUE(CCodec_BasicModule::A85Encode(src_buf_3leftover, &dest_buf,
+                                              &dest_size));
     // 5 chars for first symbol + 4 + 2 terminators.
     const uint8_t expected_out_3leftover[] = {33, 60, 78,  63,  43, 115,
                                               56, 77, 114, 126, 62};
@@ -107,16 +100,13 @@
 
 // Test all zeros comes through as "z".
 TEST(fxcodec, A85TestZeros) {
-  CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule();
-  EXPECT_TRUE(pEncoders);
-
   std::unique_ptr<uint8_t, FxFreeDeleter> dest_buf;
   uint32_t dest_size = 0;
 
   {
     // Make sure really big values don't break.
     const uint8_t src_buf[] = {1, 2, 3, 4, 0, 0, 0, 0};
-    EXPECT_TRUE(pEncoders->A85Encode(src_buf, &dest_buf, &dest_size));
+    EXPECT_TRUE(CCodec_BasicModule::A85Encode(src_buf, &dest_buf, &dest_size));
 
     // Should have 5 chars for first set of 4 + 1 for z + 2 terminators.
     const uint8_t expected_out[] = {33, 60, 78, 63, 43, 122, 126, 62};
@@ -133,7 +123,8 @@
     const uint8_t src_buf_2[] = {0, 0, 0, 0, 1, 2, 3, 4};
     dest_buf.reset();
     dest_size = 0;
-    EXPECT_TRUE(pEncoders->A85Encode(src_buf_2, &dest_buf, &dest_size));
+    EXPECT_TRUE(
+        CCodec_BasicModule::A85Encode(src_buf_2, &dest_buf, &dest_size));
 
     // Should have 5 chars for set of 4 + 1 for z + 2 terminators.
     const uint8_t expected_out_2[] = {122, 33, 60, 78, 63, 43, 126, 62};
@@ -150,7 +141,8 @@
     const uint8_t src_buf_3[] = {1, 2, 3, 4, 0, 0};
     dest_buf.reset();
     dest_size = 0;
-    EXPECT_TRUE(pEncoders->A85Encode(src_buf_3, &dest_buf, &dest_size));
+    EXPECT_TRUE(
+        CCodec_BasicModule::A85Encode(src_buf_3, &dest_buf, &dest_size));
 
     // Should have 5 chars for set of 4 + 3 for last 2 + 2 terminators.
     const uint8_t expected_out_leftover[] = {33, 60, 78, 63,  43,
@@ -185,11 +177,8 @@
   std::unique_ptr<uint8_t, FxFreeDeleter> dest_buf;
   uint32_t dest_size = 0;
 
-  CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule();
-  EXPECT_TRUE(pEncoders);
-
   // Should succeed.
-  EXPECT_TRUE(pEncoders->A85Encode(src_buf, &dest_buf, &dest_size));
+  EXPECT_TRUE(CCodec_BasicModule::A85Encode(src_buf, &dest_buf, &dest_size));
 
   // Should have 75 chars in the first row plus 2 char return,
   // 76 chars in the second row plus 2 char return,
diff --git a/core/fxcodec/codec/fx_codec_rle_unittest.cpp b/core/fxcodec/codec/fx_codec_rle_unittest.cpp
index 433d96d..b0323c1 100644
--- a/core/fxcodec/codec/fx_codec_rle_unittest.cpp
+++ b/core/fxcodec/codec/fx_codec_rle_unittest.cpp
@@ -9,7 +9,6 @@
 
 #include "core/fpdfapi/parser/fpdf_parser_decode.h"
 #include "core/fxcodec/codec/ccodec_basicmodule.h"
-#include "core/fxcodec/fx_codec.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 TEST(fxcodec, RLETestBadInputs) {
@@ -17,25 +16,22 @@
   std::unique_ptr<uint8_t, FxFreeDeleter> dest_buf;
   uint32_t dest_size = 0;
 
-  CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule();
-  EXPECT_TRUE(pEncoders);
-
   // Error codes, not segvs, should callers pass us a nullptr pointer.
-  EXPECT_FALSE(pEncoders->RunLengthEncode(src_buf, &dest_buf, nullptr));
-  EXPECT_FALSE(pEncoders->RunLengthEncode(src_buf, nullptr, &dest_size));
-  EXPECT_FALSE(pEncoders->RunLengthEncode({}, &dest_buf, &dest_size));
+  EXPECT_FALSE(
+      CCodec_BasicModule::RunLengthEncode(src_buf, &dest_buf, nullptr));
+  EXPECT_FALSE(
+      CCodec_BasicModule::RunLengthEncode(src_buf, nullptr, &dest_size));
+  EXPECT_FALSE(CCodec_BasicModule::RunLengthEncode({}, &dest_buf, &dest_size));
 }
 
 // Check length 1 input works. Check terminating character is applied.
 TEST(fxcodec, RLETestShortInput) {
-  CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule();
-  EXPECT_TRUE(pEncoders);
-
   const uint8_t src_buf[] = {1};
   std::unique_ptr<uint8_t, FxFreeDeleter> dest_buf;
   uint32_t dest_size = 0;
 
-  EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf, &dest_buf, &dest_size));
+  EXPECT_TRUE(
+      CCodec_BasicModule::RunLengthEncode(src_buf, &dest_buf, &dest_size));
   ASSERT_EQ(3u, dest_size);
   auto dest_buf_span = pdfium::make_span(dest_buf.get(), dest_size);
   EXPECT_EQ(0, dest_buf_span[0]);
@@ -46,9 +42,6 @@
 // Check a few basic cases (2 matching runs in a row, matching run followed
 // by a non-matching run, and non-matching run followed by a matching run).
 TEST(fxcodec, RLETestNormalInputs) {
-  CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule();
-  EXPECT_TRUE(pEncoders);
-
   std::unique_ptr<uint8_t, FxFreeDeleter> dest_buf;
   uint32_t dest_size = 0;
   std::unique_ptr<uint8_t, FxFreeDeleter> decoded_buf;
@@ -57,7 +50,8 @@
   {
     // Case 1: Match, match
     const uint8_t src_buf_1[] = {2, 2, 2, 2, 4, 4, 4, 4, 4, 4};
-    EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_1, &dest_buf, &dest_size));
+    EXPECT_TRUE(
+        CCodec_BasicModule::RunLengthEncode(src_buf_1, &dest_buf, &dest_size));
     RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
     ASSERT_EQ(sizeof(src_buf_1), decoded_size);
     auto decoded_buf_span = pdfium::make_span(decoded_buf.get(), decoded_size);
@@ -70,7 +64,8 @@
     const uint8_t src_buf_2[] = {2, 2, 2, 2, 1, 2, 3, 4, 5, 6};
     dest_buf.reset();
     dest_size = 0;
-    EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_2, &dest_buf, &dest_size));
+    EXPECT_TRUE(
+        CCodec_BasicModule::RunLengthEncode(src_buf_2, &dest_buf, &dest_size));
     decoded_buf.reset();
     decoded_size = 0;
     RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
@@ -85,7 +80,8 @@
     const uint8_t src_buf_3[] = {1, 2, 3, 4, 5, 3, 3, 3, 3, 3};
     dest_buf.reset();
     dest_size = 0;
-    EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_3, &dest_buf, &dest_size));
+    EXPECT_TRUE(
+        CCodec_BasicModule::RunLengthEncode(src_buf_3, &dest_buf, &dest_size));
     decoded_buf.reset();
     decoded_size = 0;
     RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
@@ -99,9 +95,6 @@
 // Check that runs longer than 128 are broken up properly, both matched and
 // non-matched.
 TEST(fxcodec, RLETestFullLengthInputs) {
-  CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule();
-  EXPECT_TRUE(pEncoders);
-
   std::unique_ptr<uint8_t, FxFreeDeleter> dest_buf;
   uint32_t dest_size = 0;
   std::unique_ptr<uint8_t, FxFreeDeleter> decoded_buf;
@@ -110,7 +103,8 @@
   {
     // Case 1: Match, match
     const uint8_t src_buf_1[260] = {1};
-    EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_1, &dest_buf, &dest_size));
+    EXPECT_TRUE(
+        CCodec_BasicModule::RunLengthEncode(src_buf_1, &dest_buf, &dest_size));
     RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
     ASSERT_EQ(sizeof(src_buf_1), decoded_size);
     auto decoded_buf_span = pdfium::make_span(decoded_buf.get(), decoded_size);
@@ -125,7 +119,8 @@
       src_buf_2[i] = static_cast<uint8_t>(i - 125);
     dest_buf.reset();
     dest_size = 0;
-    EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_2, &dest_buf, &dest_size));
+    EXPECT_TRUE(
+        CCodec_BasicModule::RunLengthEncode(src_buf_2, &dest_buf, &dest_size));
     decoded_buf.reset();
     decoded_size = 0;
     RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
@@ -142,7 +137,8 @@
       src_buf_3[i] = i;
     dest_buf.reset();
     dest_size = 0;
-    EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_3, &dest_buf, &dest_size));
+    EXPECT_TRUE(
+        CCodec_BasicModule::RunLengthEncode(src_buf_3, &dest_buf, &dest_size));
     decoded_buf.reset();
     decoded_size = 0;
     RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
@@ -159,7 +155,8 @@
       src_buf_4[i] = static_cast<uint8_t>(i);
     dest_buf.reset();
     dest_size = 0;
-    EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_4, &dest_buf, &dest_size));
+    EXPECT_TRUE(
+        CCodec_BasicModule::RunLengthEncode(src_buf_4, &dest_buf, &dest_size));
     decoded_buf.reset();
     decoded_size = 0;
     RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
diff --git a/core/fxcodec/fx_codec.h b/core/fxcodec/fx_codec.h
index bb332e9..2ab6fae 100644
--- a/core/fxcodec/fx_codec.h
+++ b/core/fxcodec/fx_codec.h
@@ -34,7 +34,6 @@
 #endif  // PDF_ENABLE_XFA_TIFF
 #endif  // PDF_ENABLE_XFA
 
-class CCodec_BasicModule;
 class CCodec_FaxModule;
 class CCodec_IccModule;
 class CCodec_Jbig2Module;
@@ -64,7 +63,6 @@
   CCodec_ModuleMgr();
   ~CCodec_ModuleMgr();
 
-  CCodec_BasicModule* GetBasicModule() const { return m_pBasicModule.get(); }
   CCodec_FaxModule* GetFaxModule() const { return m_pFaxModule.get(); }
   CCodec_JpegModule* GetJpegModule() const { return m_pJpegModule.get(); }
   CCodec_JpxModule* GetJpxModule() const { return m_pJpxModule.get(); }
@@ -104,7 +102,6 @@
 #endif  // PDF_ENABLE_XFA
 
  protected:
-  std::unique_ptr<CCodec_BasicModule> m_pBasicModule;
   std::unique_ptr<CCodec_FaxModule> m_pFaxModule;
   std::unique_ptr<CCodec_JpegModule> m_pJpegModule;
   std::unique_ptr<CCodec_JpxModule> m_pJpxModule;