Differential updates for components.

courgette/third_party/bsdiff_apply.cc

 /*-
  * Copyright 2003,2004 Colin Percival
  * All rights reserved
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted providing that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
  * Changelog:
  * 2009-03-31 - Change to use Streams.  Move CRC code to crc.{h,cc}
  *                --Stephen Adams <sra@chromium.org>
+ * 2013-04-10 - Add wrapper method to apply a patch to files directly.
+ *                --Joshua Pawlicki <waffles@chromium.org>
  */
 
 // Copyright (c) 2009 The Chromium 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 "courgette/third_party/bsdiff.h"
 
+#include "base/files/memory_mapped_file.h"
 #include "courgette/crc.h"
 #include "courgette/streams.h"
 
 namespace courgette {
 
 BSDiffStatus MBS_ReadHeader(SourceStream* stream, MBSPatchHeader* header) {
   if (!stream->Read(header->tag, sizeof(header->tag))) return READ_ERROR;
   if (!stream->ReadVarint32(&header->slen)) return READ_ERROR;
   if (!stream->ReadVarint32(&header->scrc32)) return READ_ERROR;
   if (!stream->ReadVarint32(&header->dlen)) return READ_ERROR;
@@ skipping 114 matching lines @@
   if (old_size != header.slen) return UNEXPECTED_ERROR;
 
   if (CalculateCrc(old_start, old_size) != header.scrc32)
     return CRC_ERROR;
 
   MBS_ApplyPatch(&header, patch_stream, old_start, old_size, new_stream);
 
   return OK;
 }
 
+BSDiffStatus ApplyBinaryPatch(const base::FilePath& old_file_path,
+                              const base::FilePath& patch_file_path,
+                              const base::FilePath& new_file_path) {
+  // Set up the old stream.
+  base::MemoryMappedFile old_file;
+  if (!old_file.Initialize(old_file_path)) {
+    return READ_ERROR;
+  }
+  SourceStream old_file_stream;
+  old_file_stream.Init(old_file.data(), old_file.length());
+
+  // Set up the patch stream.
+  base::MemoryMappedFile patch_file;
+  if (!patch_file.Initialize(patch_file_path)) {
+    return READ_ERROR;
+  }
+  SourceStream patch_file_stream;
+  patch_file_stream.Init(patch_file.data(), patch_file.length());
+
+  // Set up the new stream and apply the patch.
+  SinkStream new_sink_stream;
+  BSDiffStatus status = ApplyBinaryPatch(&old_file_stream,
+                                         &patch_file_stream,
+                                         &new_sink_stream);
+  if (status != OK) {
+    return status;
+  }
+
+  // Write the stream to disk.
+  int written = file_util::WriteFile(
+      new_file_path,
+      reinterpret_cast<const char*>(new_sink_stream.Buffer()),
+      static_cast<int>(new_sink_stream.Length()));
+  if (written != static_cast<int>(new_sink_stream.Length()))
+    return WRITE_ERROR;
+  return OK;
+}
+
 }  // namespace