diff --git a/payload_consumer/cached_file_descriptor.cc b/payload_consumer/cached_file_descriptor.cc
index 7f2515e..aa0dbcd 100644
--- a/payload_consumer/cached_file_descriptor.cc
+++ b/payload_consumer/cached_file_descriptor.cc
@@ -26,7 +26,7 @@
 
 namespace chromeos_update_engine {
 
-off64_t CachedFileDescriptor::Seek(off64_t offset, int whence) {
+off64_t CachedFileDescriptorBase::Seek(off64_t offset, int whence) {
   // Only support SEEK_SET and SEEK_CUR. I think these two would be enough. If
   // we want to support SEEK_END then we have to figure out the size of the
   // underlying file descriptor each time and it may not be a very good idea.
@@ -40,7 +40,7 @@
       return -1;
     }
     // Then we have to seek there.
-    if (fd_->Seek(next_offset, SEEK_SET) < 0) {
+    if (GetFd()->Seek(next_offset, SEEK_SET) < 0) {
       return -1;
     }
     offset_ = next_offset;
@@ -48,7 +48,7 @@
   return offset_;
 }
 
-ssize_t CachedFileDescriptor::Write(const void* buf, size_t count) {
+ssize_t CachedFileDescriptorBase::Write(const void* buf, size_t count) {
   auto bytes = static_cast<const uint8_t*>(buf);
   size_t total_bytes_wrote = 0;
   while (total_bytes_wrote < count) {
@@ -72,19 +72,20 @@
   return total_bytes_wrote;
 }
 
-bool CachedFileDescriptor::Flush() {
-  return FlushCache() && fd_->Flush();
+bool CachedFileDescriptorBase::Flush() {
+  return FlushCache() && GetFd()->Flush();
 }
 
-bool CachedFileDescriptor::Close() {
+bool CachedFileDescriptorBase::Close() {
   offset_ = 0;
-  return FlushCache() && fd_->Close();
+  return FlushCache() && GetFd()->Close();
 }
 
-bool CachedFileDescriptor::FlushCache() {
+bool CachedFileDescriptorBase::FlushCache() {
   size_t begin = 0;
   while (begin < bytes_cached_) {
-    auto bytes_wrote = fd_->Write(cache_.data() + begin, bytes_cached_ - begin);
+    auto bytes_wrote =
+        GetFd()->Write(cache_.data() + begin, bytes_cached_ - begin);
     if (bytes_wrote < 0) {
       PLOG(ERROR) << "Failed to flush cached data!";
       return false;
diff --git a/payload_consumer/cached_file_descriptor.h b/payload_consumer/cached_file_descriptor.h
index ada112b..1193455 100644
--- a/payload_consumer/cached_file_descriptor.h
+++ b/payload_consumer/cached_file_descriptor.h
@@ -29,45 +29,66 @@
 
 namespace chromeos_update_engine {
 
-class CachedFileDescriptor : public FileDescriptor {
+class CachedFileDescriptorBase : public FileDescriptor {
  public:
-  CachedFileDescriptor(FileDescriptorPtr fd, size_t cache_size)
-      : fd_(fd), cache_(cache_size) {}
-  ~CachedFileDescriptor() override = default;
+  CachedFileDescriptorBase(size_t cache_size) : cache_(cache_size) {}
+  ~CachedFileDescriptorBase() override = default;
 
   bool Open(const char* path, int flags, mode_t mode) override {
-    return fd_->Open(path, flags, mode);
+    return GetFd()->Open(path, flags, mode);
   }
   bool Open(const char* path, int flags) override {
-    return fd_->Open(path, flags);
+    return GetFd()->Open(path, flags);
   }
   ssize_t Read(void* buf, size_t count) override {
-    return fd_->Read(buf, count);
+    return GetFd()->Read(buf, count);
   }
   ssize_t Write(const void* buf, size_t count) override;
   off64_t Seek(off64_t offset, int whence) override;
-  uint64_t BlockDevSize() override { return fd_->BlockDevSize(); }
+  uint64_t BlockDevSize() override { return GetFd()->BlockDevSize(); }
   bool BlkIoctl(int request,
                 uint64_t start,
                 uint64_t length,
                 int* result) override {
-    return fd_->BlkIoctl(request, start, length, result);
+    return GetFd()->BlkIoctl(request, start, length, result);
   }
   bool Flush() override;
   bool Close() override;
-  bool IsSettingErrno() override { return fd_->IsSettingErrno(); }
-  bool IsOpen() override { return fd_->IsOpen(); }
+  bool IsSettingErrno() override { return GetFd()->IsSettingErrno(); }
+  bool IsOpen() override { return GetFd()->IsOpen(); }
+
+ protected:
+  virtual FileDescriptor* GetFd() = 0;
 
  private:
   // Internal flush without the need to call |fd_->Flush()|.
   bool FlushCache();
 
-  FileDescriptorPtr fd_;
   brillo::Blob cache_;
   size_t bytes_cached_{0};
   off64_t offset_{0};
 
-  DISALLOW_COPY_AND_ASSIGN(CachedFileDescriptor);
+  DISALLOW_COPY_AND_ASSIGN(CachedFileDescriptorBase);
+};
+
+class CachedFileDescriptor final : public CachedFileDescriptorBase {
+ public:
+  CachedFileDescriptor(FileDescriptorPtr fd, size_t cache_size)
+      : CachedFileDescriptorBase(cache_size), fd_(fd) {}
+
+ protected:
+  virtual FileDescriptor* GetFd() { return fd_.get(); }
+  FileDescriptorPtr fd_;
+};
+
+class UnownedCachedFileDescriptor final : public CachedFileDescriptorBase {
+ public:
+  UnownedCachedFileDescriptor(FileDescriptor* fd, size_t cache_size)
+      : CachedFileDescriptorBase(cache_size), fd_(fd) {}
+
+ protected:
+  virtual FileDescriptor* GetFd() { return fd_; }
+  FileDescriptor* fd_;
 };
 
 }  // namespace chromeos_update_engine
diff --git a/payload_consumer/partition_writer.cc b/payload_consumer/partition_writer.cc
index 4625a7a..b94f8c7 100644
--- a/payload_consumer/partition_writer.cc
+++ b/payload_consumer/partition_writer.cc
@@ -86,8 +86,6 @@
 
 }  // namespace
 
-using google::protobuf::RepeatedPtrField;
-
 // Opens path for read/write. On success returns an open FileDescriptor
 // and sets *err to 0. On failure, sets *err to errno and returns nullptr.
 FileDescriptorPtr OpenFile(const char* path,
diff --git a/payload_consumer/verity_writer_android.cc b/payload_consumer/verity_writer_android.cc
index b233b58..b669b4d 100644
--- a/payload_consumer/verity_writer_android.cc
+++ b/payload_consumer/verity_writer_android.cc
@@ -161,6 +161,11 @@
   std::unique_ptr<void, decltype(&free_rs_char)> rs_char(
       init_rs_char(FEC_PARAMS(fec_roots)), &free_rs_char);
   TEST_AND_RETURN_FALSE(rs_char != nullptr);
+  // Cache at most 1MB of fec data, in VABC, we need to re-open fd if we
+  // perform a read() operation after write(). So reduce the number of writes
+  // can save unnecessary re-opens.
+  UnownedCachedFileDescriptor cache_fd(write_fd, 1 * (1 << 20));
+  write_fd = &cache_fd;
 
   for (size_t i = 0; i < rounds; i++) {
     // Encodes |block_size| number of rs blocks each round so that we can read