diff --git a/core/fxcrt/cfx_bitstream.cpp b/core/fxcrt/cfx_bitstream.cpp
index 7b1e502..406552a 100644
--- a/core/fxcrt/cfx_bitstream.cpp
+++ b/core/fxcrt/cfx_bitstream.cpp
@@ -10,11 +10,11 @@
 
 #include "core/fxcrt/fx_memory.h"
 #include "core/fxcrt/fx_system.h"
-#include "third_party/base/check.h"
+#include "third_party/base/check_op.h"
 
 CFX_BitStream::CFX_BitStream(pdfium::span<const uint8_t> pData)
     : m_BitSize(pData.size() * 8), m_pData(pData.data()) {
-  DCHECK(pData.size() <= std::numeric_limits<uint32_t>::max() / 8);
+  CHECK_LE(pData.size(), std::numeric_limits<size_t>::max() / 8);
 }
 
 CFX_BitStream::~CFX_BitStream() = default;
@@ -30,12 +30,12 @@
     return 0;
 
   const uint32_t bit_pos = m_BitPos % 8;
-  uint32_t byte_pos = m_BitPos / 8;
+  size_t byte_pos = m_BitPos / 8;
   const uint8_t* data = m_pData.Get();
   uint8_t current_byte = data[byte_pos];
 
   if (nBits == 1) {
-    int bit = (current_byte & (1 << (7 - bit_pos))) ? 1 : 0;
+    uint32_t bit = (current_byte & (1 << (7 - bit_pos))) ? 1 : 0;
     m_BitPos++;
     return bit;
   }
diff --git a/core/fxcrt/cfx_bitstream.h b/core/fxcrt/cfx_bitstream.h
index 731a637..1b3cdd8 100644
--- a/core/fxcrt/cfx_bitstream.h
+++ b/core/fxcrt/cfx_bitstream.h
@@ -7,6 +7,7 @@
 #ifndef CORE_FXCRT_CFX_BITSTREAM_H_
 #define CORE_FXCRT_CFX_BITSTREAM_H_
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "core/fxcrt/unowned_ptr.h"
@@ -20,19 +21,19 @@
   void ByteAlign();
 
   bool IsEOF() const { return m_BitPos >= m_BitSize; }
-  uint32_t GetPos() const { return m_BitPos; }
+  size_t GetPos() const { return m_BitPos; }
   uint32_t GetBits(uint32_t nBits);
 
-  void SkipBits(uint32_t nBits) { m_BitPos += nBits; }
+  void SkipBits(size_t nBits) { m_BitPos += nBits; }
   void Rewind() { m_BitPos = 0; }
 
-  uint32_t BitsRemaining() const {
+  size_t BitsRemaining() const {
     return m_BitSize >= m_BitPos ? m_BitSize - m_BitPos : 0;
   }
 
  private:
-  uint32_t m_BitPos = 0;
-  const uint32_t m_BitSize;
+  size_t m_BitPos = 0;
+  const size_t m_BitSize;
   UnownedPtr<const uint8_t> const m_pData;
 };
 
diff --git a/core/fxcrt/cfx_bitstream_unittest.cpp b/core/fxcrt/cfx_bitstream_unittest.cpp
index 2ba3663..35688c4 100644
--- a/core/fxcrt/cfx_bitstream_unittest.cpp
+++ b/core/fxcrt/cfx_bitstream_unittest.cpp
@@ -3,6 +3,9 @@
 // found in the LICENSE file.
 
 #include "core/fxcrt/cfx_bitstream.h"
+
+#include <limits>
+
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
@@ -116,6 +119,63 @@
   EXPECT_TRUE(bitstream.IsEOF());
   EXPECT_EQ(1063U, bitstream.GetPos());
   EXPECT_EQ(0U, bitstream.BitsRemaining());
+  EXPECT_EQ(0u, bitstream.GetBits(4));
+
+  // Align past the end.
+  bitstream.ByteAlign();
+  EXPECT_TRUE(bitstream.IsEOF());
+  EXPECT_EQ(1064U, bitstream.GetPos());
+  EXPECT_EQ(0U, bitstream.BitsRemaining());
+  EXPECT_EQ(0u, bitstream.GetBits(4));
+}
+
+TEST(fxcrt, BitStreamEmpty) {
+  CFX_BitStream bitstream({});
+  EXPECT_TRUE(bitstream.IsEOF());
+  EXPECT_EQ(0U, bitstream.GetPos());
+  EXPECT_EQ(0U, bitstream.BitsRemaining());
+
+  // Getting bits returns zero and doesn't advance.
+  EXPECT_EQ(0u, bitstream.GetBits(4));
+  EXPECT_EQ(0U, bitstream.GetPos());
+
+  // Skip past the end.
+  bitstream.SkipBits(63);
+  EXPECT_TRUE(bitstream.IsEOF());
+  EXPECT_EQ(63U, bitstream.GetPos());
+  EXPECT_EQ(0U, bitstream.BitsRemaining());
+  EXPECT_EQ(0u, bitstream.GetBits(4));
+
+  // Align past the end.
+  bitstream.ByteAlign();
+  EXPECT_TRUE(bitstream.IsEOF());
+  EXPECT_EQ(64U, bitstream.GetPos());
+  EXPECT_EQ(0U, bitstream.BitsRemaining());
+  EXPECT_EQ(0u, bitstream.GetBits(4));
+}
+
+TEST(fxcrt, BitStreamBig) {
+  // We can't actually allocate enough memory to test the limits of
+  // the bitstream arithmetic, but as long as we don't try to extract
+  // any bits, the calculations should be unaffected.
+  constexpr size_t kAllocationBytes = std::numeric_limits<size_t>::max() / 8;
+  constexpr size_t kAllocationBits = kAllocationBytes * 8;
+  CFX_BitStream bitstream({nullptr, kAllocationBytes});
+  EXPECT_FALSE(bitstream.IsEOF());
+  EXPECT_EQ(0U, bitstream.GetPos());
+  EXPECT_EQ(kAllocationBits, bitstream.BitsRemaining());
+
+  // Skip some bits.
+  bitstream.SkipBits(kAllocationBits - 1023);
+  EXPECT_FALSE(bitstream.IsEOF());
+  EXPECT_EQ(kAllocationBits - 1023, bitstream.GetPos());
+  EXPECT_EQ(1023u, bitstream.BitsRemaining());
+
+  // Align to byte.
+  bitstream.ByteAlign();
+  EXPECT_FALSE(bitstream.IsEOF());
+  EXPECT_EQ(kAllocationBits - 1016, bitstream.GetPos());
+  EXPECT_EQ(1016u, bitstream.BitsRemaining());
 }
 
 TEST(fxcrt, BitStreamSameAsReferenceGetBits32) {