Merge 75787 - Improved memory usage while applying patch....

courgette/courgette_tool.cc

 // 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 <vector>
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 34 matching lines @@
   va_end(args);
   exit(1);
 }
 
 std::string ReadOrFail(const std::wstring& file_name, const char* kind) {
 #if defined(OS_WIN)
   FilePath file_path(file_name);
 #else
   FilePath file_path(WideToASCII(file_name));
 #endif
+  int64 file_size = 0;
+  if (!file_util::GetFileSize(file_path, &file_size))
+    Problem("Can't read %s file.", kind);
   std::string buffer;
+  buffer.reserve(static_cast<size_t>(file_size));
   if (!file_util::ReadFileToString(file_path, &buffer))
     Problem("Can't read %s file.", kind);
   return buffer;
 }
 
 void WriteSinkToFile(const courgette::SinkStream *sink,
                      const std::wstring& output_file) {
 #if defined(OS_WIN)
   FilePath output_path(output_file);
 #else
@@ skipping 212 matching lines @@
       courgette::GenerateEnsemblePatch(&old_stream, &new_stream, &patch_stream);
 
   if (status != courgette::C_OK) Problem("-gen failed.");
 
   WriteSinkToFile(&patch_stream, patch_file);
 }
 
 void ApplyEnsemblePatch(const std::wstring& old_file,
                         const std::wstring& patch_file,
                         const std::wstring& new_file) {
+  // We do things a little differently here in order to call the same Courgette
+  // entry point as the installer.  That entry point point takes file names and
+  // returns an status code but does not output any diagnostics.
+#if defined(OS_WIN)
+  FilePath old_path(old_file);
+  FilePath patch_path(patch_file);
+  FilePath new_path(new_file);
+#else
+  FilePath old_path(WideToASCII(old_file));
+  FilePath patch_path(WideToASCII(patch_file));
+  FilePath new_path(WideToASCII(new_file));
+#endif
+
+  courgette::Status status =
+    courgette::ApplyEnsemblePatch(old_path.value().c_str(),
+                                  patch_path.value().c_str(),
+                                  new_path.value().c_str());
+
+  if (status == courgette::C_OK)
+    return;
+
+  // Diagnose the error.
+  if (status == courgette::C_BAD_ENSEMBLE_MAGIC)
+    Problem("Not a courgette patch");
+  if (status == courgette::C_BAD_ENSEMBLE_VERSION)
+    Problem("Wrong version patch");
+  if (status == courgette::C_BAD_ENSEMBLE_HEADER)
+    Problem("Corrupt patch");
+  //  If we failed due to a missing input file, this will
+  // print the message.
   std::string old_buffer = ReadOrFail(old_file, "'old' input");
+  old_buffer.clear();
   std::string patch_buffer = ReadOrFail(patch_file, "'patch' input");
+  patch_buffer.clear();
 
-  courgette::SourceStream old_stream;
-  courgette::SourceStream patch_stream;
-  old_stream.Init(old_buffer);
-  patch_stream.Init(patch_buffer);
-  courgette::SinkStream new_stream;
-  courgette::Status status =
-      courgette::ApplyEnsemblePatch(&old_stream, &patch_stream, &new_stream);
+  // Non-input related errors:
+  if (status == courgette::C_WRITE_OPEN_ERROR)
+    Problem("Can't open output");
+  if (status == courgette::C_WRITE_ERROR)
+    Problem("Can't write output");
 
-  if (status != courgette::C_OK) Problem("-apply failed.");
-
-  WriteSinkToFile(&new_stream, new_file);
+  Problem("-apply failed.");
 }
 
 void GenerateBSDiffPatch(const std::wstring& old_file,
                          const std::wstring& new_file,
                          const std::wstring& patch_file) {
   std::string old_buffer = ReadOrFail(old_file, "'old' input");
   std::string new_buffer = ReadOrFail(new_file, "'new' input");
 
   courgette::SourceStream old_stream;
   courgette::SourceStream new_stream;
@@ skipping 110 matching lines @@
     } else if (cmd_spread_1_adjusted || cmd_spread_1_unadjusted) {
       if (values.size() != 3)
         UsageProblem("-gen1[au] <old_file> <new_file> <patch_files_root>");
       DisassembleAdjustDiff(values[0], values[1], values[2],
                             cmd_spread_1_adjusted);
     } else {
       UsageProblem("No operation specified");
     }
   }
 }