diff --git a/src/fuzzer.cc b/src/fuzzer.cc
index 0ea63ce..b870ac4 100644
--- a/src/fuzzer.cc
+++ b/src/fuzzer.cc
@@ -97,6 +97,15 @@
       TestExtentsArrayForFuzzer(src_puffs) &&
       TestExtentsArrayForFuzzer(dst_puffs)) {
     const size_t kBufferSize = 1000;
+    if ((!src_deflates.empty() &&
+         kBufferSize <
+             src_deflates.back().offset + src_deflates.back().length) ||
+        (!dst_deflates.empty() &&
+         kBufferSize <
+             dst_deflates.back().offset + dst_deflates.back().length)) {
+      return;
+    }
+
     Buffer src_buffer(kBufferSize);
     Buffer dst_buffer(kBufferSize);
     auto src = MemoryStream::CreateForRead(src_buffer);
diff --git a/src/main.cc b/src/main.cc
index 79fc4f2..12f823f 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -275,7 +275,7 @@
       auto huffer = std::make_shared<Huffer>();
       auto huff_writer = PuffinStream::CreateForHuff(
           std::move(dst_stream), huffer, dst_puff_size, dst_deflates_bit,
-          src_puffs, /*ignore_deflate_size=*/true);
+          src_puffs);
 
       uint64_t bytes_read = 0;
       while (bytes_read < dst_puff_size) {
@@ -300,8 +300,7 @@
     auto huffer = std::make_shared<Huffer>();
     auto dst_stream = PuffinStream::CreateForHuff(std::move(dst_file), huffer,
                                                   src_stream_size,
-                                                  dst_deflates_bit, src_puffs,
-                                                  /*ignore_deflate_size=*/true);
+                                                  dst_deflates_bit, src_puffs);
 
     Buffer buffer(1024 * 1024);
     uint64_t bytes_read = 0;
diff --git a/src/puffin_stream.cc b/src/puffin_stream.cc
index ff79ea2..91d0dd7 100644
--- a/src/puffin_stream.cc
+++ b/src/puffin_stream.cc
@@ -28,9 +28,7 @@
 
 namespace {
 
-bool CheckArgsIntegrity(uint64_t deflate_size,
-                        bool ignore_deflate_size,
-                        uint64_t puff_size,
+bool CheckArgsIntegrity(uint64_t puff_size,
                         const std::vector<BitExtent>& deflates,
                         const std::vector<ByteExtent>& puffs) {
   TEST_AND_RETURN_FALSE(puffs.size() == deflates.size());
@@ -39,10 +37,6 @@
   if (!puffs.empty()) {
     TEST_AND_RETURN_FALSE(puff_size >=
                           puffs.back().offset + puffs.back().length);
-    if (!ignore_deflate_size) {
-      TEST_AND_RETURN_FALSE(deflate_size * 8 >=
-                            deflates.back().offset + deflates.back().length);
-    }
   }
 
   // Check to make sure |puffs| and |deflates| are sorted and non-overlapping.
@@ -67,12 +61,8 @@
     const std::vector<BitExtent>& deflates,
     const std::vector<ByteExtent>& puffs,
     size_t max_cache_size) {
-  uint64_t deflate_size = 0;
-  TEST_AND_RETURN_VALUE(stream->GetSize(&deflate_size), nullptr);
-  TEST_AND_RETURN_VALUE(
-      CheckArgsIntegrity(deflate_size, /*ignore_deflate_size=*/false, puff_size,
-                         deflates, puffs),
-      nullptr);
+  TEST_AND_RETURN_VALUE(CheckArgsIntegrity(puff_size, deflates, puffs),
+                        nullptr);
   TEST_AND_RETURN_VALUE(stream->Seek(0), nullptr);
 
   UniqueStreamPtr puffin_stream(new PuffinStream(std::move(stream), puffer,
@@ -87,14 +77,8 @@
     std::shared_ptr<Huffer> huffer,
     uint64_t puff_size,
     const std::vector<BitExtent>& deflates,
-    const std::vector<ByteExtent>& puffs,
-    bool ignore_deflate_size) {
-  uint64_t deflate_size = 0;
-  if (!ignore_deflate_size) {
-    TEST_AND_RETURN_VALUE(stream->GetSize(&deflate_size), nullptr);
-  }
-  TEST_AND_RETURN_VALUE(CheckArgsIntegrity(deflate_size, ignore_deflate_size,
-                                           puff_size, deflates, puffs),
+    const std::vector<ByteExtent>& puffs) {
+  TEST_AND_RETURN_VALUE(CheckArgsIntegrity(puff_size, deflates, puffs),
                         nullptr);
   TEST_AND_RETURN_VALUE(stream->Seek(0), nullptr);
 
diff --git a/src/puffin_stream.h b/src/puffin_stream.h
index 9e12467..47b8ace 100644
--- a/src/puffin_stream.h
+++ b/src/puffin_stream.h
@@ -57,14 +57,11 @@
   //                 completely puffed.
   // |deflates|  IN  The location of deflates in |stream|.
   // |puffs|     IN  The location of puffs into the input puff stream.
-  // |ignore_deflate_size| IN  Ignores integrity checking the size of the
-  //                           |stream|.
   static UniqueStreamPtr CreateForHuff(UniqueStreamPtr stream,
                                        std::shared_ptr<Huffer> huffer,
                                        uint64_t puff_size,
                                        const std::vector<BitExtent>& deflates,
-                                       const std::vector<ByteExtent>& puffs,
-                                       bool ignore_deflate_size);
+                                       const std::vector<ByteExtent>& puffs);
 
   bool GetSize(uint64_t* size) const override;
 
diff --git a/src/puffin_unittest.cc b/src/puffin_unittest.cc
index 669ae30..8efcfe3 100644
--- a/src/puffin_unittest.cc
+++ b/src/puffin_unittest.cc
@@ -212,8 +212,7 @@
 
     src_puffin_stream =
         PuffinStream::CreateForHuff(std::move(deflate_stream), huffer,
-                                    puff_size, deflate_extents, puff_extents,
-                                    /*ignore_deflate_size=*/true);
+                                    puff_size, deflate_extents, puff_extents);
 
     ASSERT_TRUE(
         src_puffin_stream->Write(puff_buffer.data(), puff_buffer.size()));
@@ -575,29 +574,4 @@
                              kGapPuffs, kGapPuffExtents);
 }
 
-TEST_F(PuffinTest, IgnoreDeflateSizeTest) {
-  std::shared_ptr<Huffer> huffer(new Huffer());
-  Buffer out_deflate_buffer;
-  EXPECT_FALSE(PuffinStream::CreateForHuff(
-      MemoryStream::CreateForWrite(&out_deflate_buffer), huffer,
-      kGapPuffs.size(), kGapSubblockDeflateExtents, kGapPuffExtents,
-      /*ignore_deflate_size=*/false));
-
-  EXPECT_TRUE(PuffinStream::CreateForHuff(
-      MemoryStream::CreateForWrite(&out_deflate_buffer), huffer,
-      kGapPuffs.size(), kGapSubblockDeflateExtents, kGapPuffExtents,
-      /*ignore_deflate_size=*/true));
-
-  out_deflate_buffer.resize(kGapDeflates.size());
-  EXPECT_TRUE(PuffinStream::CreateForHuff(
-      MemoryStream::CreateForWrite(&out_deflate_buffer), huffer,
-      kGapPuffs.size(), kGapSubblockDeflateExtents, kGapPuffExtents,
-      /*ignore_deflate_size=*/true));
-
-  EXPECT_TRUE(PuffinStream::CreateForHuff(
-      MemoryStream::CreateForWrite(&out_deflate_buffer), huffer,
-      kGapPuffs.size(), kGapSubblockDeflateExtents, kGapPuffExtents,
-      /*ignore_deflate_size=*/false));
-}
-
 }  // namespace puffin
diff --git a/src/puffpatch.cc b/src/puffpatch.cc
index 2c499a3..2dd3a29 100644
--- a/src/puffpatch.cc
+++ b/src/puffpatch.cc
@@ -164,8 +164,7 @@
 
   // For writing into destination.
   auto writer = BsdiffStream::Create(PuffinStream::CreateForHuff(
-      std::move(dst), huffer, dst_puff_size, dst_deflates, dst_puffs,
-      /*ignore_deflate_size=*/false));
+      std::move(dst), huffer, dst_puff_size, dst_deflates, dst_puffs));
   TEST_AND_RETURN_FALSE(writer);
 
   // Running bspatch itself.
diff --git a/src/stream_unittest.cc b/src/stream_unittest.cc
index 30813ee..76fe34b 100644
--- a/src/stream_unittest.cc
+++ b/src/stream_unittest.cc
@@ -218,8 +218,7 @@
   shared_ptr<Huffer> huffer(new Huffer());
   auto write_stream = PuffinStream::CreateForHuff(
       MemoryStream::CreateForWrite(&buf), huffer, kPuffsSample1.size(),
-      kSubblockDeflateExtentsSample1, kPuffExtentsSample1,
-      /*ignore_deflate_size=*/false);
+      kSubblockDeflateExtentsSample1, kPuffExtentsSample1);
 
   ASSERT_TRUE(write_stream->Seek(0));
   for (size_t idx = 0; idx < kPuffsSample1.size(); idx++) {