Provide interface for in memory bspatch. am: 716d569273 am: 2cfaa534b7 am: c8ccf4be29

am: e4916dff22

Change-Id: I03719d4a4f0d648116fc4c5b5f7a6f9e6396e156

10 files changed, 341 insertions, 127 deletions

diff --git a/Android.mk b/Android.mk
index 12ee3e8..1073005 100644
--- a/Android.mk
+++ b/Android.mk
@@ -37,10 +37,12 @@ bsdiff_src_files := \
 # "bspatch" program.
 bspatch_src_files := \
     bspatch.cc \
+    buffer_file.cc \
     extents.cc \
     extents_file.cc \
     file.cc \
-    memory_file.cc
+    memory_file.cc \
+    sink_file.cc
 
 # Unit test files.
 bsdiff_common_unittests := \
@@ -57,6 +59,7 @@ LOCAL_MODULE := libbspatch
 LOCAL_CPP_EXTENSION := .cc
 LOCAL_SRC_FILES := $(bspatch_src_files)
 LOCAL_CFLAGS := $(bsdiff_common_cflags)
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
 LOCAL_STATIC_LIBRARIES := $(bsdiff_common_static_libs)
 include $(BUILD_STATIC_LIBRARY)
 
@@ -76,6 +79,7 @@ LOCAL_MODULE := libbspatch
 LOCAL_CPP_EXTENSION := .cc
 LOCAL_SRC_FILES := $(bspatch_src_files)
 LOCAL_CFLAGS := $(bsdiff_common_cflags)
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
 LOCAL_STATIC_LIBRARIES := $(bsdiff_common_static_libs)
 include $(BUILD_HOST_STATIC_LIBRARY)
 
diff --git a/Makefile b/Makefile
index fbfe56a..4214637 100644
--- a/Makefile
+++ b/Makefile
@@ -32,10 +32,12 @@ BSDIFF_OBJS = \
 BSPATCH_LIBS = -lbz2
 BSPATCH_OBJS = \
   bspatch.o \
+  buffer_file.o \
   extents.o \
   extents_file.o \
   file.o \
-  memory_file.o
+  memory_file.o \
+  sink_file.o
 
 UNITTEST_LIBS = -lgmock -lgtest -lpthread
 UNITTEST_OBJS = \
@@ -66,6 +68,7 @@ bspatch.o: bspatch.cc bspatch.h extents.h extents_file.h file_interface.h \
  file.h
 bspatch_main.o: bspatch_main.cc bspatch.h
 bspatch_unittest.o: bspatch_unittest.cc bspatch.h test_utils.h
+buffer_file.o: buffer_file.cc buffer_file.h file_interface.h bspatch.h
 extents.o: extents.cc extents.h extents_file.h file_interface.h
 extents_file.o: extents_file.cc extents_file.h file_interface.h
 extents_file_unittest.o: extents_file_unittest.cc extents_file.h \
@@ -74,6 +77,7 @@ extents_unittest.o: extents_unittest.cc extents.h extents_file.h \
  file_interface.h
 file.o: file.cc file.h file_interface.h
 memory_file.o: memory_file.cc memory_file.h file_interface.h
+sink_file.o: sink_file.cc sink_file.h file_interface.h
 testrunner.o: testrunner.cc
 test_utils.o: test_utils.cc test_utils.h
 
diff --git a/bspatch.cc b/bspatch.cc
index 550c6c7..693213a 100644
--- a/bspatch.cc
+++ b/bspatch.cc
@@ -46,15 +46,17 @@ __FBSDID("$FreeBSD: src/usr.bin/bsdiff/bspatch/bspatch.c,v 1.1 2005/08/06 01:59:
 #include <limits>
 #include <vector>
 
+#include "buffer_file.h"
 #include "extents.h"
 #include "extents_file.h"
 #include "file.h"
 #include "file_interface.h"
 #include "memory_file.h"
+#include "sink_file.h"
 
 namespace {
 
-int64_t ParseInt64(u_char* buf) {
+int64_t ParseInt64(const u_char* buf) {
   int64_t y;
 
   y = buf[7] & 0x7F;
@@ -79,22 +81,28 @@ int64_t ParseInt64(u_char* buf) {
   return y;
 }
 
-bool ReadBZ2(BZFILE* pfbz2, uint8_t* data, size_t size) {
-  int bz2err;
-  size_t lenread = BZ2_bzRead(&bz2err, pfbz2, data, size);
-  if (lenread < size || (bz2err != BZ_OK && bz2err != BZ_STREAM_END))
-    return false;
+bool ReadBZ2(bz_stream* stream, uint8_t* data, size_t size) {
+  stream->next_out = (char*)data;
+  while (size > 0) {
+    unsigned int read_size = std::min(
+        static_cast<size_t>(std::numeric_limits<unsigned int>::max()), size);
+    stream->avail_out = read_size;
+    int bz2err = BZ2_bzDecompress(stream);
+    if (bz2err != BZ_OK && bz2err != BZ_STREAM_END)
+      return false;
+    size -= read_size - stream->avail_out;
+  }
   return true;
 }
 
 bool ReadBZ2AndWriteAll(const std::unique_ptr<bsdiff::FileInterface>& file,
-                        BZFILE* pfbz2,
+                        bz_stream* stream,
                         size_t size,
                         uint8_t* buf,
                         size_t buf_size) {
   while (size > 0) {
     size_t bytes_to_read = std::min(size, buf_size);
-    if (!ReadBZ2(pfbz2, buf, bytes_to_read))
+    if (!ReadBZ2(stream, buf, bytes_to_read))
       return false;
     if (!WriteAll(file, buf, bytes_to_read))
       return false;
@@ -107,6 +115,18 @@ bool ReadBZ2AndWriteAll(const std::unique_ptr<bsdiff::FileInterface>& file,
 
 namespace bsdiff {
 
+bool ReadAll(const std::unique_ptr<FileInterface>& file,
+             uint8_t* data,
+             size_t size) {
+  size_t offset = 0, read;
+  while (offset < size) {
+    if (!file->Read(data + offset, size - offset, &read) || read == 0)
+      return false;
+    offset += read;
+  }
+  return true;
+}
+
 bool WriteAll(const std::unique_ptr<FileInterface>& file,
               const uint8_t* data,
               size_t size) {
@@ -151,78 +171,23 @@ int bspatch(
     const char* old_filename, const char* new_filename,
     const char* patch_filename,
     const char* old_extents, const char* new_extents) {
-  FILE* f, *cpf, *dpf, *epf;
-  BZFILE* cpfbz2, *dpfbz2, *epfbz2;
-  int bz2err;
-  ssize_t bzctrllen, bzdatalen;
-  u_char header[32], buf[8];
-  off_t ctrl[3];
-
-  int using_extents = (old_extents != NULL || new_extents != NULL);
-
-  // Open patch file.
-  if ((f = fopen(patch_filename, "r")) == NULL)
-    err(1, "fopen(%s)", patch_filename);
-
-  // File format:
-  //   0       8    "BSDIFF40"
-  //   8       8    X
-  //   16      8    Y
-  //   24      8    sizeof(new_filename)
-  //   32      X    bzip2(control block)
-  //   32+X    Y    bzip2(diff block)
-  //   32+X+Y  ???  bzip2(extra block)
-  // with control block a set of triples (x,y,z) meaning "add x bytes
-  // from oldfile to x bytes from the diff block; copy y bytes from the
-  // extra block; seek forwards in oldfile by z bytes".
-
-  // Read header.
-  if (fread(header, 1, 32, f) < 32) {
-    if (feof(f))
-      errx(1, "Corrupt patch\n");
-    err(1, "fread(%s)", patch_filename);
-  }
-
-  // Check for appropriate magic.
-  if (memcmp(header, "BSDIFF40", 8) != 0)
-    errx(1, "Corrupt patch\n");
-
-  // Read lengths from header.
-  uint64_t oldsize, newsize;
-  bzctrllen = ParseInt64(header + 8);
-  bzdatalen = ParseInt64(header + 16);
-  int64_t signed_newsize = ParseInt64(header + 24);
-  newsize = signed_newsize;
-  if ((bzctrllen < 0) || (bzdatalen < 0) || (signed_newsize < 0))
+  std::unique_ptr<FileInterface> patch_file =
+      File::FOpen(patch_filename, O_RDONLY);
+  if (!patch_file)
+    err(1, "Error opening the patch filename %s", patch_filename);
+  uint64_t patch_size;
+  patch_file->GetSize(&patch_size);
+  std::vector<uint8_t> patch(patch_size);
+  if (!ReadAll(patch_file, patch.data(), patch_size))
     errx(1, "Corrupt patch\n");
+  patch_file.reset();
 
-  // Close patch file and re-open it via libbzip2 at the right places.
-  if (fclose(f))
-    err(1, "fclose(%s)", patch_filename);
-  if ((cpf = fopen(patch_filename, "r")) == NULL)
-    err(1, "fopen(%s)", patch_filename);
-  if (fseek(cpf, 32, SEEK_SET))
-    err(1, "fseeko(%s, %lld)", patch_filename, (long long)32);
-  if ((cpfbz2 = BZ2_bzReadOpen(&bz2err, cpf, 0, 0, NULL, 0)) == NULL)
-    errx(1, "BZ2_bzReadOpen, bz2err = %d", bz2err);
-  if ((dpf = fopen(patch_filename, "r")) == NULL)
-    err(1, "fopen(%s)", patch_filename);
-  if (fseek(dpf, 32 + bzctrllen, SEEK_SET))
-    err(1, "fseeko(%s, %lld)", patch_filename, (long long)(32 + bzctrllen));
-  if ((dpfbz2 = BZ2_bzReadOpen(&bz2err, dpf, 0, 0, NULL, 0)) == NULL)
-    errx(1, "BZ2_bzReadOpen, bz2err = %d", bz2err);
-  if ((epf = fopen(patch_filename, "r")) == NULL)
-    err(1, "fopen(%s)", patch_filename);
-  if (fseek(epf, 32 + bzctrllen + bzdatalen, SEEK_SET))
-    err(1, "fseeko(%s, %lld)", patch_filename,
-        (long long)(32 + bzctrllen + bzdatalen));
-  if ((epfbz2 = BZ2_bzReadOpen(&bz2err, epf, 0, 0, NULL, 0)) == NULL)
-    errx(1, "BZ2_bzReadOpen, bz2err = %d", bz2err);
+  int using_extents = (old_extents != NULL || new_extents != NULL);
 
   // Open input file for reading.
   std::unique_ptr<FileInterface> old_file = File::FOpen(old_filename, O_RDONLY);
   if (!old_file)
-    err(1, "Error opening the old filename");
+    err(1, "Error opening the old filename %s", old_filename);
 
   std::vector<ex_t> parsed_old_extents;
   if (using_extents) {
@@ -231,10 +196,6 @@ int bspatch(
     old_file.reset(new ExtentsFile(std::move(old_file), parsed_old_extents));
   }
 
-  if (!old_file->GetSize(&oldsize))
-    err(1, "cannot obtain the size of %s", old_filename);
-  uint64_t old_file_pos = 0;
-
   // Open output file for writing.
   std::unique_ptr<FileInterface> new_file =
       File::FOpen(new_filename, O_CREAT | O_WRONLY);
@@ -251,10 +212,91 @@ int bspatch(
   if (IsOverlapping(old_filename, new_filename, parsed_old_extents,
                     parsed_new_extents)) {
     // New and old file is overlapping, we can not stream output to new file,
-    // cache it in the memory and write to the file at the end.
-    new_file.reset(new MemoryFile(std::move(new_file), newsize));
+    // cache it in a buffer and write to the file at the end.
+    uint64_t newsize = ParseInt64(patch.data() + 24);
+    new_file.reset(new BufferFile(std::move(new_file), newsize));
   }
 
+  return bspatch(old_file, new_file, patch.data(), patch_size);
+}
+
+int bspatch(const uint8_t* old_data,
+            size_t old_size,
+            const uint8_t* patch_data,
+            size_t patch_size,
+            const sink_func& sink) {
+  std::unique_ptr<FileInterface> old_file(new MemoryFile(old_data, old_size));
+  std::unique_ptr<FileInterface> new_file(new SinkFile(sink));
+
+  return bspatch(old_file, new_file, patch_data, patch_size);
+}
+
+int bspatch(const std::unique_ptr<FileInterface>& old_file,
+            const std::unique_ptr<FileInterface>& new_file,
+            const uint8_t* patch_data,
+            size_t patch_size) {
+  int bz2err;
+  u_char buf[8];
+  off_t ctrl[3];
+
+  // File format:
+  //   0       8    "BSDIFF40"
+  //   8       8    X
+  //   16      8    Y
+  //   24      8    sizeof(new_filename)
+  //   32      X    bzip2(control block)
+  //   32+X    Y    bzip2(diff block)
+  //   32+X+Y  ???  bzip2(extra block)
+  // with control block a set of triples (x,y,z) meaning "add x bytes
+  // from oldfile to x bytes from the diff block; copy y bytes from the
+  // extra block; seek forwards in oldfile by z bytes".
+
+  // Check for appropriate magic.
+  if (memcmp(patch_data, "BSDIFF40", 8) != 0)
+    errx(1, "Corrupt patch\n");
+
+  // Read lengths from header.
+  uint64_t oldsize, newsize;
+  int64_t ctrl_len = ParseInt64(patch_data + 8);
+  int64_t data_len = ParseInt64(patch_data + 16);
+  int64_t signed_newsize = ParseInt64(patch_data + 24);
+  newsize = signed_newsize;
+  if ((ctrl_len < 0) || (data_len < 0) || (signed_newsize < 0) ||
+      (32 + ctrl_len + data_len > static_cast<int64_t>(patch_size)))
+    errx(1, "Corrupt patch\n");
+
+  bz_stream cstream;
+  cstream.next_in = (char*)patch_data + 32;
+  cstream.avail_in = ctrl_len;
+  cstream.bzalloc = nullptr;
+  cstream.bzfree = nullptr;
+  cstream.opaque = nullptr;
+  if ((bz2err = BZ2_bzDecompressInit(&cstream, 0, 0)) != BZ_OK)
+    errx(1, "failed to bzinit control stream (%d)\n", bz2err);
+
+  bz_stream dstream;
+  dstream.next_in = (char*)patch_data + 32 + ctrl_len;
+  dstream.avail_in = data_len;
+  dstream.bzalloc = nullptr;
+  dstream.bzfree = nullptr;
+  dstream.opaque = nullptr;
+  if ((bz2err = BZ2_bzDecompressInit(&dstream, 0, 0)) != BZ_OK)
+    errx(1, "failed to bzinit diff stream (%d)\n", bz2err);
+
+  bz_stream estream;
+  estream.next_in = (char*)patch_data + 32 + ctrl_len + data_len;
+  estream.avail_in = patch_size - (32 + ctrl_len + data_len);
+  estream.bzalloc = nullptr;
+  estream.bzfree = nullptr;
+  estream.opaque = nullptr;
+  if ((bz2err = BZ2_bzDecompressInit(&estream, 0, 0)) != BZ_OK)
+    errx(1, "failed to bzinit extra stream (%d)\n", bz2err);
+
+  uint64_t old_file_pos = 0;
+
+  if (!old_file->GetSize(&oldsize))
+    err(1, "cannot obtain the size of old file");
+
   // The oldpos can be negative, but the new pos is only incremented linearly.
   int64_t oldpos = 0;
   uint64_t newpos = 0;
@@ -263,7 +305,7 @@ int bspatch(
     int64_t i;
     // Read control data.
     for (i = 0; i <= 2; i++) {
-      if (!ReadBZ2(cpfbz2, buf, 8))
+      if (!ReadBZ2(&cstream, buf, 8))
         errx(1, "Corrupt patch\n");
       ctrl[i] = ParseInt64(buf);
     }
@@ -281,7 +323,7 @@ int bspatch(
     if ((i = oldpos) < 0) {
       // Write diff block directly to new file without adding old data,
       // because we will skip part where |oldpos| < 0.
-      if (!ReadBZ2AndWriteAll(new_file, dpfbz2, -i, new_buf.data(),
+      if (!ReadBZ2AndWriteAll(new_file, &dstream, -i, new_buf.data(),
                               new_buf.size()))
         errx(1, "Error during ReadBZ2AndWriteAll()");
 
@@ -303,7 +345,7 @@ int bspatch(
       if (!read_bytes)
         errx(1, "EOF reached while reading from input file");
       // Read same amount of bytes from diff block
-      if (!ReadBZ2(dpfbz2, new_buf.data(), read_bytes))
+      if (!ReadBZ2(&dstream, new_buf.data(), read_bytes))
         errx(1, "Corrupt patch\n");
       // new_buf already has data from diff block, adds old data to it.
       for (size_t k = 0; k < read_bytes; k++)
@@ -320,7 +362,7 @@ int bspatch(
     if (oldpos > static_cast<int64_t>(oldsize)) {
       // Write diff block directly to new file without adding old data,
       // because we skipped part where |oldpos| > oldsize.
-      if (!ReadBZ2AndWriteAll(new_file, dpfbz2, oldpos - oldsize,
+      if (!ReadBZ2AndWriteAll(new_file, &dstream, oldpos - oldsize,
                               new_buf.data(), new_buf.size()))
         errx(1, "Error during ReadBZ2AndWriteAll()");
     }
@@ -330,7 +372,7 @@ int bspatch(
       errx(1, "Corrupt patch\n");
 
     // Read extra block.
-    if (!ReadBZ2AndWriteAll(new_file, epfbz2, ctrl[1], new_buf.data(),
+    if (!ReadBZ2AndWriteAll(new_file, &estream, ctrl[1], new_buf.data(),
                             new_buf.size()))
       errx(1, "Error during ReadBZ2AndWriteAll()");
 
@@ -343,14 +385,12 @@ int bspatch(
   old_file->Close();
 
   // Clean up the bzip2 reads.
-  BZ2_bzReadClose(&bz2err, cpfbz2);
-  BZ2_bzReadClose(&bz2err, dpfbz2);
-  BZ2_bzReadClose(&bz2err, epfbz2);
-  if (fclose(cpf) || fclose(dpf) || fclose(epf))
-    err(1, "fclose(%s)", patch_filename);
+  BZ2_bzDecompressEnd(&cstream);
+  BZ2_bzDecompressEnd(&dstream);
+  BZ2_bzDecompressEnd(&estream);
 
   if (!new_file->Close())
-    err(1, "Error closing new file %s", new_filename);
+    err(1, "Error closing new file");
 
   return 0;
 }
diff --git a/bspatch.h b/bspatch.h
index 3de2874..2507879 100644
--- a/bspatch.h
+++ b/bspatch.h
@@ -5,6 +5,7 @@
 #ifndef _BSDIFF_BSPATCH_H_
 #define _BSDIFF_BSPATCH_H_
 
+#include <functional>
 #include <memory>
 #include <vector>
 
@@ -18,6 +19,17 @@ int bspatch(const char* old_filename,
             const char* old_extents,
             const char* new_extents);
 
+int bspatch(const uint8_t* old_data,
+            size_t old_size,
+            const uint8_t* patch_data,
+            size_t patch_size,
+            const std::function<size_t(const uint8_t*, size_t)>& sink);
+
+int bspatch(const std::unique_ptr<FileInterface>& old_file,
+            const std::unique_ptr<FileInterface>& new_file,
+            const uint8_t* patch_data,
+            size_t patch_size);
+
 bool WriteAll(const std::unique_ptr<FileInterface>& file,
               const uint8_t* data,
               size_t size);
diff --git a/buffer_file.cc b/buffer_file.cc
new file mode 100644
index 0000000..1e1c213
--- /dev/null
+++ b/buffer_file.cc
@@ -0,0 +1,49 @@
+// Copyright 2016 The Chromium OS 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 "buffer_file.h"
+
+#include "bspatch.h"
+
+namespace bsdiff {
+
+BufferFile::BufferFile(std::unique_ptr<FileInterface> file, size_t size)
+    : file_(std::move(file)) {
+  buffer_.reserve(size);
+}
+
+BufferFile::~BufferFile() {
+  Close();
+}
+
+bool BufferFile::Read(void* buf, size_t count, size_t* bytes_read) {
+  return false;
+}
+
+bool BufferFile::Write(const void* buf, size_t count, size_t* bytes_written) {
+  const uint8_t* data = static_cast<const uint8_t*>(buf);
+  buffer_.insert(buffer_.end(), data, data + count);
+  *bytes_written = count;
+  return true;
+}
+
+bool BufferFile::Seek(off_t pos) {
+  return false;
+}
+
+bool BufferFile::Close() {
+  if (!WriteAll(file_, buffer_.data(), buffer_.size()))
+    return false;
+  // Prevent writing |buffer_| to |file_| again if Close() is called more than
+  // once.
+  buffer_.clear();
+  return file_->Close();
+}
+
+bool BufferFile::GetSize(uint64_t* size) {
+  *size = buffer_.size();
+  return true;
+}
+
+}  // namespace bsdiff
diff --git a/buffer_file.h b/buffer_file.h
new file mode 100644
index 0000000..514225b
--- /dev/null
+++ b/buffer_file.h
@@ -0,0 +1,41 @@
+// Copyright 2016 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef _BSDIFF_BUFFER_FILE_H_
+#define _BSDIFF_BUFFER_FILE_H_
+
+#include <memory>
+#include <vector>
+
+#include "file_interface.h"
+
+namespace bsdiff {
+
+class BufferFile : public FileInterface {
+ public:
+  // Creates a write only BufferFile based on the underlying |file| passed.
+  // The BufferFile will cache all the write in a buffer and write everything
+  // to |file| at once upon closing. Read and Seek are not supported.
+  // |size| should be the estimated total file size, it is used to reserve
+  // buffer space.
+  BufferFile(std::unique_ptr<FileInterface> file, size_t size);
+
+  ~BufferFile() override;
+
+  // FileInterface overrides.
+  bool Read(void* buf, size_t count, size_t* bytes_read) override;
+  bool Write(const void* buf, size_t count, size_t* bytes_written) override;
+  bool Seek(off_t pos) override;
+  bool Close() override;
+  bool GetSize(uint64_t* size) override;
+
+ private:
+  // The underlying FileInterace instance.
+  std::unique_ptr<FileInterface> file_ = nullptr;
+  std::vector<uint8_t> buffer_;
+};
+
+}  // namespace bsdiff
+
+#endif  // _BSDIFF_BUFFER_FILE_H_
diff --git a/memory_file.cc b/memory_file.cc
index 59e2c7d..ec179b9 100644
--- a/memory_file.cc
+++ b/memory_file.cc
@@ -4,45 +4,39 @@
 
 #include "memory_file.h"
 
-#include "bspatch.h"
+#include <algorithm>
+#include <string.h>
 
 namespace bsdiff {
 
-MemoryFile::MemoryFile(std::unique_ptr<FileInterface> file, size_t size)
-    : file_(std::move(file)) {
-  buffer_.reserve(size);
-}
-
-MemoryFile::~MemoryFile() {
-  Close();
-}
+MemoryFile::MemoryFile(const uint8_t* data, size_t size)
+    : data_(data), size_(size) {}
 
 bool MemoryFile::Read(void* buf, size_t count, size_t* bytes_read) {
-  return false;
+  count = std::min(count, static_cast<size_t>(size_ - offset_));
+  memcpy(buf, data_ + offset_, count);
+  offset_ += count;
+  *bytes_read = count;
+  return true;
 }
 
 bool MemoryFile::Write(const void* buf, size_t count, size_t* bytes_written) {
-  const uint8_t* data = static_cast<const uint8_t*>(buf);
-  buffer_.insert(buffer_.end(), data, data + count);
-  *bytes_written = count;
-  return true;
+  return false;
 }
 
 bool MemoryFile::Seek(off_t pos) {
-  return false;
+  if (pos > static_cast<off_t>(size_) || pos < 0)
+    return false;
+  offset_ = pos;
+  return true;
 }
 
 bool MemoryFile::Close() {
-  if (!WriteAll(file_, buffer_.data(), buffer_.size()))
-    return false;
-  // Prevent writing |buffer_| to |file_| again if Close() is called more than
-  // once.
-  buffer_.clear();
-  return file_->Close();
+  return true;
 }
 
 bool MemoryFile::GetSize(uint64_t* size) {
-  *size = buffer_.size();
+  *size = size_;
   return true;
 }
 
diff --git a/memory_file.h b/memory_file.h
index 3e80b8a..2833649 100644
--- a/memory_file.h
+++ b/memory_file.h
@@ -6,7 +6,6 @@
 #define _BSDIFF_MEMORY_FILE_H_
 
 #include <memory>
-#include <vector>
 
 #include "file_interface.h"
 
@@ -14,14 +13,12 @@ namespace bsdiff {
 
 class MemoryFile : public FileInterface {
  public:
-  // Creates a MemoryFile based on the underlying |file| passed. The MemoryFile
-  // will cache all the write in memory and write it to to |file| when it's
-  // closed. MemoryFile does not support read and seek.
-  // |size| should be the estimated total file size, it is used to reserve
-  // buffer space.
-  MemoryFile(std::unique_ptr<FileInterface> file, size_t size);
+  // Creates a read only MemoryFile based on the underlying |data| passed.
+  // The MemoryFile will use data starting from |data| with length of |size| as
+  // the file content. Write is not supported.
+  MemoryFile(const uint8_t* data, size_t size);
 
-  ~MemoryFile() override;
+  ~MemoryFile() = default;
 
   // FileInterface overrides.
   bool Read(void* buf, size_t count, size_t* bytes_read) override;
@@ -31,10 +28,9 @@ class MemoryFile : public FileInterface {
   bool GetSize(uint64_t* size) override;
 
  private:
-  // The underlying FileInterace instance.
-  std::unique_ptr<FileInterface> file_;
-
-  std::vector<uint8_t> buffer_;
+  const uint8_t* data_ = nullptr;
+  size_t size_ = 0;
+  off_t offset_ = 0;
 };
 
 }  // namespace bsdiff
diff --git a/sink_file.cc b/sink_file.cc
new file mode 100644
index 0000000..5cbd3bd
--- /dev/null
+++ b/sink_file.cc
@@ -0,0 +1,33 @@
+// Copyright 2016 The Chromium OS 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 "sink_file.h"
+
+namespace bsdiff {
+
+SinkFile::SinkFile(const sink_func& sink)
+    : sink_(sink) {}
+
+bool SinkFile::Read(void* buf, size_t count, size_t* bytes_read) {
+  return false;
+}
+
+bool SinkFile::Write(const void* buf, size_t count, size_t* bytes_written) {
+  *bytes_written = sink_(static_cast<const uint8_t*>(buf), count);
+  return true;
+}
+
+bool SinkFile::Seek(off_t pos) {
+  return false;
+}
+
+bool SinkFile::Close() {
+  return true;
+}
+
+bool SinkFile::GetSize(uint64_t* size) {
+  return false;
+}
+
+}  // namespace bsdiff
diff --git a/sink_file.h b/sink_file.h
new file mode 100644
index 0000000..b2ce33f
--- /dev/null
+++ b/sink_file.h
@@ -0,0 +1,41 @@
+// Copyright 2016 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef _BSDIFF_SINK_FILE_H_
+#define _BSDIFF_SINK_FILE_H_
+
+#include <stdint.h>
+
+#include <functional>
+
+#include "file_interface.h"
+
+using sink_func = std::function<size_t(const uint8_t*, size_t)>;
+
+namespace bsdiff {
+
+class SinkFile : public FileInterface {
+ public:
+  // Creates a SinkFile based on the underlying |sink| function passed.
+  // The SinkFile will call |sink| function upon write.
+  // Read, Seek and GetSize are not supported.
+  explicit SinkFile(const sink_func& sink);
+
+  ~SinkFile() = default;
+
+  // FileInterface overrides.
+  bool Read(void* buf, size_t count, size_t* bytes_read) override;
+  bool Write(const void* buf, size_t count, size_t* bytes_written) override;
+  bool Seek(off_t pos) override;
+  bool Close() override;
+  bool GetSize(uint64_t* size) override;
+
+ private:
+  // The sink() function used to write data.
+  const sink_func& sink_;
+};
+
+}  // namespace bsdiff
+
+#endif  // _BSDIFF_SINK_FILE_H_