Switching all wstrings in courgette_tool to FilePaths.

courgette/courgette_tool.cc

 // Copyright (c) 2011 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 28 matching lines @@
 
 void Problem(const char* format, ...) {
   va_list args;
   va_start(args, format);
   vfprintf(stderr, format, args);
   fprintf(stderr, "\n");
   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
+std::string ReadOrFail(const FilePath& file_name, const char* kind) {
   int64 file_size = 0;
-  if (!file_util::GetFileSize(file_path, &file_size))
+  if (!file_util::GetFileSize(file_name, &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))
+  if (!file_util::ReadFileToString(file_name, &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
-  FilePath output_path(WideToASCII(output_file));
-#endif
+                     const FilePath& output_file) {
   int count =
-      file_util::WriteFile(output_path,
+      file_util::WriteFile(output_file,
                            reinterpret_cast<const char*>(sink->Buffer()),
                            static_cast<int>(sink->Length()));
   if (count == -1)
     Problem("Can't write output.");
   if (static_cast<size_t>(count) != sink->Length())
     Problem("Incomplete write.");
 }
 
-void Disassemble(const std::wstring& input_file,
-                 const std::wstring& output_file) {
+void Disassemble(const FilePath& input_file,
+                 const FilePath& output_file) {
   std::string buffer = ReadOrFail(input_file, "input");
 
   courgette::AssemblyProgram* program = NULL;
   const courgette::Status parse_status =
       courgette::ParseDetectedExecutable(buffer.c_str(), buffer.length(),
                                          &program);
 
   if (parse_status != courgette::C_OK)
     Problem("Can't parse input.");
 
@@ skipping 14 matching lines @@
 
   courgette::DeleteEncodedProgram(encoded);
 
   courgette::SinkStream sink;
   if (!sinks.CopyTo(&sink))
     Problem("Can't combine serialized encoded program streams.");
 
   WriteSinkToFile(&sink, output_file);
 }
 
-void DisassembleAndAdjust(const std::wstring& program_file,
-                          const std::wstring& model_file,
-                          const std::wstring& output_file) {
+void DisassembleAndAdjust(const FilePath& program_file,
+                          const FilePath& model_file,
+                          const FilePath& output_file) {
   std::string program_buffer = ReadOrFail(program_file, "program");
   std::string model_buffer = ReadOrFail(model_file, "reference");
 
   courgette::AssemblyProgram* program = NULL;
   const courgette::Status parse_program_status =
       courgette::ParseDetectedExecutable(program_buffer.c_str(),
                                          program_buffer.length(),
                                          &program);
   if (parse_program_status != courgette::C_OK)
     Problem("Can't parse program input.");
@@ skipping 32 matching lines @@
     Problem("Can't combine serialized encoded program streams.");
 
   WriteSinkToFile(&sink, output_file);
 }
 
 // Diffs two executable files, write a set of files for the diff, one file per
 // stream of the EncodedProgram format.  Each file is the bsdiff between the
 // original file's stream and the new file's stream.  This is completely
 // uninteresting to users, but it is handy for seeing how much each which
 // streams are contributing to the final file size.  Adjustment is optional.
-void DisassembleAdjustDiff(const std::wstring& model_file,
-                           const std::wstring& program_file,
-                           const std::wstring& output_file_root,
+void DisassembleAdjustDiff(const FilePath& model_file,
+                           const FilePath& program_file,
+                           const FilePath& output_file_root,
                            bool adjust) {
   std::string model_buffer = ReadOrFail(model_file, "'old'");
   std::string program_buffer = ReadOrFail(program_file, "'new'");
 
   courgette::AssemblyProgram* model = NULL;
   const courgette::Status parse_model_status =
       courgette::ParseDetectedExecutable(model_buffer.c_str(),
                                          model_buffer.length(),
                                          &model);
   if (parse_model_status != courgette::C_OK)
@@ skipping 49 matching lines @@
 
     courgette::SourceStream old_source;
     courgette::SourceStream new_source;
     old_source.Init(old_stream ? *old_stream : empty_sink);
     new_source.Init(new_stream ? *new_stream : empty_sink);
     courgette::SinkStream patch_stream;
     courgette::BSDiffStatus status =
         courgette::CreateBinaryPatch(&old_source, &new_source, &patch_stream);
     if (status != courgette::OK) Problem("-xxx failed.");
 
+    FilePath::StringType append = FilePath::StringType("-") +
+                                  base::IntToString(i);
+
     WriteSinkToFile(&patch_stream,
-                    output_file_root + L"-" + UTF8ToWide(base::IntToString(i)));
+                    output_file_root.InsertBeforeExtension(append));
   }
 }
 
-void Assemble(const std::wstring& input_file,
-              const std::wstring& output_file) {
+void Assemble(const FilePath& input_file,
+              const FilePath& output_file) {
   std::string buffer = ReadOrFail(input_file, "input");
 
   courgette::SourceStreamSet sources;
   if (!sources.Init(buffer.c_str(), buffer.length()))
     Problem("Bad input file.");
 
   courgette::EncodedProgram* encoded = NULL;
   const courgette::Status read_status = ReadEncodedProgram(&sources, &encoded);
   if (read_status != courgette::C_OK)
     Problem("Bad encoded program.");
 
   courgette::SinkStream sink;
 
   const courgette::Status assemble_status = courgette::Assemble(encoded, &sink);
   if (assemble_status != courgette::C_OK)
     Problem("Can't assemble.");
 
   WriteSinkToFile(&sink, output_file);
 }
 
-void GenerateEnsemblePatch(const std::wstring& old_file,
-                           const std::wstring& new_file,
-                           const std::wstring& patch_file) {
+void GenerateEnsemblePatch(const FilePath& old_file,
+                           const FilePath& new_file,
+                           const FilePath& 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;
   old_stream.Init(old_buffer);
   new_stream.Init(new_buffer);
 
   courgette::SinkStream patch_stream;
   courgette::Status status =
       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) {
+void ApplyEnsemblePatch(const FilePath& old_file,
+                        const FilePath& patch_file,
+                        const FilePath& 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());
+      courgette::ApplyEnsemblePatch(old_file.value().c_str(),
+                                    patch_file.value().c_str(),
+                                    new_file.value().c_str());
 
   if (status == courgette::C_OK)
     return;
 
   // Diagnose the error.
   switch (status) {
     case courgette::C_BAD_ENSEMBLE_MAGIC:
       Problem("Not a courgette patch");
       break;
 
@@ skipping 26 matching lines @@
 
   // 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");
 
   Problem("-apply failed.");
 }
 
-void GenerateBSDiffPatch(const std::wstring& old_file,
-                         const std::wstring& new_file,
-                         const std::wstring& patch_file) {
+void GenerateBSDiffPatch(const FilePath& old_file,
+                         const FilePath& new_file,
+                         const FilePath& 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;
   old_stream.Init(old_buffer);
   new_stream.Init(new_buffer);
 
   courgette::SinkStream patch_stream;
   courgette::BSDiffStatus status =
       courgette::CreateBinaryPatch(&old_stream, &new_stream, &patch_stream);
 
   if (status != courgette::OK) Problem("-genbsdiff failed.");
 
   WriteSinkToFile(&patch_stream, patch_file);
 }
 
-void ApplyBSDiffPatch(const std::wstring& old_file,
-                      const std::wstring& patch_file,
-                      const std::wstring& new_file) {
+void ApplyBSDiffPatch(const FilePath& old_file,
+                      const FilePath& patch_file,
+                      const FilePath& new_file) {
   std::string old_buffer = ReadOrFail(old_file, "'old' input");
   std::string patch_buffer = ReadOrFail(patch_file, "'patch' input");
 
   courgette::SourceStream old_stream;
   courgette::SourceStream patch_stream;
   old_stream.Init(old_buffer);
   patch_stream.Init(patch_buffer);
 
   courgette::SinkStream new_stream;
   courgette::BSDiffStatus status =
@@ skipping 20 matching lines @@
   bool cmd_dis = command_line.HasSwitch("dis");
   bool cmd_asm = command_line.HasSwitch("asm");
   bool cmd_disadj = command_line.HasSwitch("disadj");
   bool cmd_make_patch = command_line.HasSwitch("gen");
   bool cmd_apply_patch = command_line.HasSwitch("apply");
   bool cmd_make_bsdiff_patch = command_line.HasSwitch("genbsdiff");
   bool cmd_apply_bsdiff_patch = command_line.HasSwitch("applybsdiff");
   bool cmd_spread_1_adjusted = command_line.HasSwitch("gen1a");
   bool cmd_spread_1_unadjusted = command_line.HasSwitch("gen1u");
 
-  // TODO(evanm): this whole file should use FilePaths instead of wstrings.
-  std::vector<std::wstring> values;
+  std::vector<FilePath> values;
   const CommandLine::StringVector& args = command_line.GetArgs();
   for (size_t i = 0; i < args.size(); ++i) {
 #if defined(OS_WIN)
-    values.push_back(args[i]);
+    values.push_back(FilePath(args[i]));
 #else
-    values.push_back(ASCIIToWide(args[i]));
+    values.push_back(FilePath(args[i]));

[sra1, 2011/11/16 21:04:25]

Can remove the #if now.
Just test this runs on Windows (does the trybot run courgette from a script? -
that should be adequate.)

[dgarrett, 2011/11/17 22:44:02]

Done.

 #endif
   }
 
   // '-repeat=N' is for debugging.  Running many iterations can reveal leaks and
   // bugs in cleanup.
   int repeat_count = 1;
   std::string repeat_switch = command_line.GetSwitchValueASCII("repeat");
   if (!repeat_switch.empty())
     if (!base::StringToInt(repeat_switch, &repeat_count))
       repeat_count = 1;
@@ skipping 38 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");
     }
   }
 }