Get generate_dump compiling on Windows

tools/generate_dump.cc

Index: tools/generate_dump.cc
diff --git a/tools/generate_dump.cc b/tools/generate_dump.cc
index ecb1bda08b32836c6ff2732bffe4ccc25c560391..2419c63b56bb7d933173438854e3c2b490dd1f42 100644
--- a/tools/generate_dump.cc
+++ b/tools/generate_dump.cc
@@ -14,27 +14,37 @@
 
 #include <fcntl.h>
 #include <getopt.h>
-#include <libgen.h>
-#include <mach/mach.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <unistd.h>
+#include <sys/types.h>
 
 #include <string>
 
 #include "base/logging.h"
-#include "base/mac/scoped_mach_port.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
+#include "build/build_config.h"
 #include "minidump/minidump_file_writer.h"
-#include "snapshot/mac/process_snapshot_mac.h"
 #include "tools/tool_support.h"
+#include "util/file/basename.h"
 #include "util/file/file_writer.h"
-#include "util/mach/scoped_task_suspend.h"
-#include "util/mach/task_for_pid.h"
 #include "util/posix/drop_privileges.h"
 #include "util/stdlib/string_number_conversion.h"
 
+#if defined(OS_MACOSX)
+#include <libgen.h>
+#include <mach/mach.h>
+#include <unistd.h>
+
+#include "base/mac/scoped_mach_port.h"
+#include "snapshot/mac/process_snapshot_mac.h"
+#include "util/mach/scoped_task_suspend.h"
+#include "util/mach/task_for_pid.h"
+#elif defined(OS_WIN)
+#include "base/strings/utf_string_conversions.h"
+#include "snapshot/win/process_snapshot_win.h"
+#endif  // OS_MACOSX
+
 namespace crashpad {
 namespace {
 
@@ -58,7 +68,7 @@ void Usage(const std::string& me) {
 }
 
 int GenerateDumpMain(int argc, char* argv[]) {
-  const std::string me(basename(argv[0]));
+  const std::string me(Basename(argv[0]));
 
   enum OptionFlags {
     // “Short” (single-character) options.
@@ -117,6 +127,7 @@ int GenerateDumpMain(int argc, char* argv[]) {
     return EXIT_FAILURE;
   }
 
+#if defined(OS_MACOSX)

[Mark Mentovai, 2015/05/04 21:21:58]

I hope that over time, we can refactor things well enough to the point that the
code doesn’t have to be structured as “if-Mac-elseif-Win, if-Mac-elseif-Win”
over and over.

[scottmg, 2015/05/05 19:26:22]

OK. It seems that having a typedef for task_t/process HANDLE would get us some
of the way. That would allow for a ScopedProcessSuspend (with the same name) and
a factory function to create a snapshot. There's still the process opening that
talks to OS-level things, but that could be moved to a helper function at least.

[Mark Mentovai, 2015/05/05 22:41:35]

scottmg wrote:
Yup, that would be a good future change.

   task_t task = TaskForPID(options.pid);
   if (task == TASK_NULL) {
     return EXIT_FAILURE;
@@ -134,24 +145,51 @@ int GenerateDumpMain(int argc, char* argv[]) {
     }
     LOG(WARNING) << "operating on myself";
   }
+#elif defined(OS_WIN)
+  ScopedKernelHANDLE process(
+      OpenProcess(PROCESS_ALL_ACCESS, false, options.pid));
+  if (!process.is_valid()) {
+    LOG(ERROR) << "could not open process " << options.pid;
+    return EXIT_FAILURE;
+  }
+#endif  // OS_MACOSX
 
   if (options.dump_path.empty()) {
     options.dump_path = base::StringPrintf("minidump.%d", options.pid);
   }
 
   {
+#if defined(OS_MACOSX)
     scoped_ptr<ScopedTaskSuspend> suspend;
     if (options.suspend) {
       suspend.reset(new ScopedTaskSuspend(task));
     }
+#elif defined(OS_WIN)
+    if (options.suspend) {
+      LOG(ERROR) << "TODO(scottmg): --suspend not implemented yet.";
+      return EXIT_FAILURE;
+    }
+#endif  // OS_MACOSX
 
+#if defined(OS_MACOSX)
     ProcessSnapshotMac process_snapshot;
     if (!process_snapshot.Initialize(task)) {
       return EXIT_FAILURE;
     }
+#elif defined(OS_WIN)
+    ProcessSnapshotWin process_snapshot;
+    if (!process_snapshot.Initialize(process.get())) {
+      return EXIT_FAILURE;
+    }
+#endif  // OS_MACOSX
 
     FileWriter file_writer;
-    if (!file_writer.Open(base::FilePath(options.dump_path),
+#if defined(OS_MACOSX)
+    base::FilePath dump_path(options.dump_path);
+#elif defined(OS_WIN)
+    base::FilePath dump_path(base::UTF8ToUTF16(options.dump_path));
+#endif  // OS_MACOSX
+    if (!file_writer.Open(dump_path,
                           FileWriteMode::kTruncateOrCreate,
                           FilePermissions::kWorldReadable)) {
       return EXIT_FAILURE;