Improved memory usage while applying patch....

courgette/ensemble_apply.cc

 // Copyright (c) 2010 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.
 
 // This file contains the code to apply a Courgette patch.
 
 #include "courgette/ensemble.h"
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
+#include "base/logging.h"
 
 #include "courgette/crc.h"
 #include "courgette/image_info.h"
 #include "courgette/region.h"
 #include "courgette/streams.h"
 #include "courgette/simple_delta.h"
 #include "courgette/win32_x86_patcher.h"
 
 namespace courgette {
 
@@ skipping 35 matching lines @@
  private:
   Status SubpatchStreamSets(SinkStreamSet* predicted_items,
                             SourceStream* correction,
                             SourceStreamSet* corrected_items,
                             SinkStream* corrected_items_storage);
 
   Region base_region_;       // Location of in-memory copy of 'old' version.
 
   uint32 source_checksum_;
   uint32 target_checksum_;
+  uint32 final_patch_input_size_prediction_;
 
   std::vector<TransformationPatcher*> patchers_;
 
   SinkStream corrected_parameters_storage_;
   SinkStream corrected_elements_storage_;
 
   DISALLOW_COPY_AND_ASSIGN(EnsemblePatchApplication);
 };
 
 EnsemblePatchApplication::EnsemblePatchApplication()
-    : source_checksum_(0), target_checksum_(0) {
+    : source_checksum_(0), target_checksum_(0),
+      final_patch_input_size_prediction_(0) {
 }
 
 EnsemblePatchApplication::~EnsemblePatchApplication() {
   for (size_t i = 0;  i < patchers_.size();  ++i) {
     delete patchers_[i];
   }
 }
 
 Status EnsemblePatchApplication::ReadHeader(SourceStream* header_stream) {
   uint32 magic;
   if (!header_stream->ReadVarint32(&magic))
     return C_BAD_ENSEMBLE_MAGIC;
 
   if (magic != CourgettePatchFile::kMagic)
     return C_BAD_ENSEMBLE_MAGIC;
 
   uint32 version;
   if (!header_stream->ReadVarint32(&version))
     return C_BAD_ENSEMBLE_VERSION;
 
   if (version != CourgettePatchFile::kVersion)
     return C_BAD_ENSEMBLE_VERSION;
 
   if (!header_stream->ReadVarint32(&source_checksum_))
     return C_BAD_ENSEMBLE_HEADER;
 
   if (!header_stream->ReadVarint32(&target_checksum_))
     return C_BAD_ENSEMBLE_HEADER;
 
+  if (!header_stream->ReadVarint32(&final_patch_input_size_prediction_))
+    return C_BAD_ENSEMBLE_HEADER;
+
   return C_OK;
 }
 
 Status EnsemblePatchApplication::InitBase(const Region& region) {
   base_region_.assign(region);
   return C_OK;
 }
 
 Status EnsemblePatchApplication::ValidateBase() {
   uint32 checksum = CalculateCrc(base_region_.start(), base_region_.length());
@@ skipping 91 matching lines @@
                             correction,
                             corrected_elements,
                             &corrected_elements_storage_);
 }
 
 Status EnsemblePatchApplication::TransformDown(
     SourceStreamSet* transformed_elements,
     SinkStream* basic_elements) {
   // Construct blob of original input followed by reformed elements.
 
+  basic_elements->Reserve(final_patch_input_size_prediction_);
+
   // The original input:
   basic_elements->Write(base_region_.start(), base_region_.length());
 
   for (size_t i = 0;  i < patchers_.size();  ++i) {
     SourceStreamSet single_corrected_element;
     if (!transformed_elements->ReadSet(&single_corrected_element))
       return C_STREAM_ERROR;
     Status status = patchers_[i]->Reform(&single_corrected_element,
                                          basic_elements);
     if (status != C_OK)
       return status;
     if (!single_corrected_element.Empty())
       return C_STREAM_NOT_CONSUMED;
   }
 
   if (!transformed_elements->Empty())
     return C_STREAM_NOT_CONSUMED;
+  corrected_elements_storage_.Retire();
 
   return C_OK;
 }
 
 Status EnsemblePatchApplication::SubpatchFinalOutput(
     SourceStream* original,
     SourceStream* correction,
     SinkStream* corrected_ensemble) {
   Status delta_status = ApplySimpleDelta(original, correction,
                                          corrected_ensemble);
@@ skipping 123 matching lines @@
 
   // 'Dry-run' the first step of the patch process to validate format of header.
   SourceStream patch_header_stream;
   patch_header_stream.Init(buffer, read_count);
   EnsemblePatchApplication patch_process;
   status = patch_process.ReadHeader(&patch_header_stream);
   if (status != C_OK)
     return status;
 
   // Header smells good so read the whole patch file for real.
+  int64 patch_file_size = 0;
+  if (!file_util::GetFileSize(patch_file_path, &patch_file_size))
+    return C_READ_ERROR;
   std::string patch_file_buffer;
+  patch_file_buffer.reserve(static_cast<size_t>(patch_file_size));
   if (!file_util::ReadFileToString(patch_file_path, &patch_file_buffer))
     return C_READ_ERROR;
 
   // Read the old_file.
   FilePath old_file_path(old_file_name);
+  int64 old_file_size = 0;
+  if (!file_util::GetFileSize(old_file_path, &old_file_size))
+    return C_READ_ERROR;
   std::string old_file_buffer;
+  old_file_buffer.reserve(static_cast<size_t>(old_file_size));
   if (!file_util::ReadFileToString(old_file_path, &old_file_buffer))
     return C_READ_ERROR;
 
   // Apply patch on streams.
   SourceStream old_source_stream;
   SourceStream patch_source_stream;
   old_source_stream.Init(old_file_buffer);
   patch_source_stream.Init(patch_file_buffer);
   SinkStream new_sink_stream;
   status = ApplyEnsemblePatch(&old_source_stream, &patch_source_stream,
                               &new_sink_stream);
 
   // Write the patched data to |new_file_name|.
   FilePath new_file_path(new_file_name);
   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 == -1)
     return C_WRITE_OPEN_ERROR;
   if (static_cast<size_t>(written) != new_sink_stream.Length())
     return C_WRITE_ERROR;
 
   return C_OK;
 }
 
 }  // namespace