win: Make reading NT_IMAGE_HEADERS work cross-bitness

snapshot/win/exception_snapshot_win_test.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "snapshot/win/exception_snapshot_win.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "client/crashpad_client.h"
 #include "gtest/gtest.h"
 #include "snapshot/win/process_snapshot_win.h"
 #include "test/paths.h"
-#include "test/win/win_child_process.h"
+#include "test/win/child_launcher.h"
+#include "util/file/file_io.h"
 #include "util/thread/thread.h"
 #include "util/win/exception_handler_server.h"
 #include "util/win/registration_protocol_win.h"
 #include "util/win/scoped_handle.h"
 #include "util/win/scoped_process_suspend.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
@@ skipping 112 matching lines @@
   WaitForSingleObject(server_ready.get(), INFINITE);
 
   // Spawn a child process, passing it the pipe name to connect to.
   base::FilePath test_executable = Paths::Executable();
   std::wstring child_test_executable =
       test_executable.DirName()
           .Append(directory_modification)
           .Append(test_executable.BaseName().RemoveFinalExtension().value() +
                   L"_crashing_child.exe")
           .value();
-
-  // Create a pipe for the stdout of the child.
-  SECURITY_ATTRIBUTES security_attributes = {0};
-  security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
-  security_attributes.bInheritHandle = true;
-  HANDLE stdout_read;
-  HANDLE stdout_write;
-  ASSERT_TRUE(CreatePipe(&stdout_read, &stdout_write, &security_attributes, 0));
-  ScopedFileHANDLE read_handle(stdout_read);
-  ScopedFileHANDLE write_handle(stdout_write);
-  ASSERT_TRUE(SetHandleInformation(read_handle.get(), HANDLE_FLAG_INHERIT, 0));
-
-  std::wstring command_line =
-      child_test_executable + L" " + base::UTF8ToUTF16(pipe_name);
-  STARTUPINFO startup_info = {0};
-  startup_info.cb = sizeof(startup_info);
-  startup_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
-  startup_info.hStdOutput = write_handle.get();
-  startup_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
-  startup_info.dwFlags = STARTF_USESTDHANDLES;
-  PROCESS_INFORMATION process_information;
-  ASSERT_TRUE(CreateProcess(child_test_executable.c_str(),
-                            &command_line[0],
-                            nullptr,
-                            nullptr,
-                            true,
-                            0,
-                            nullptr,
-                            nullptr,
-                            &startup_info,
-                            &process_information));
-  // Take ownership of the two process handles returned.
-  ScopedKernelHANDLE process_main_thread_handle(process_information.hThread);
-  ScopedKernelHANDLE process_handle(process_information.hProcess);
+  ChildLauncher child(child_test_executable, base::UTF8ToUTF16(pipe_name));
+  child.Start();
 
   // The child tells us (approximately) where it will crash.
   WinVMAddress break_near_address;
-  LoggingReadFile(
-      read_handle.get(), &break_near_address, sizeof(break_near_address));
+  LoggingReadFile(child.stdout_read_handle(),
+                  &break_near_address,
+                  sizeof(break_near_address));
   delegate.set_break_near(break_near_address);
 
   // Wait for the child to crash and the exception information to be validated.
   WaitForSingleObject(completed.get(), INFINITE);
 }
 
 TEST(ExceptionSnapshotWinTest, ChildCrash) {
   TestCrashingChild(FILE_PATH_LITERAL("."));
 }
 
 #if defined(ARCH_CPU_64_BITS)
 TEST(ExceptionSnapshotWinTest, ChildCrashWOW64) {
 #ifndef NDEBUG
   TestCrashingChild(FILE_PATH_LITERAL("..\\..\\out\\Debug"));
 #else
   TestCrashingChild(FILE_PATH_LITERAL("..\\..\\out\\Release"));
 #endif
 }
 #endif  // ARCH_CPU_64_BITS
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad