win: support x64 reading x86 (wow64)

util/win/process_info_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,
@@ skipping 85 matching lines @@
   EXPECT_GT(modules[0].size, 0);
   EXPECT_GT(modules[1].size, 0);
 
   EXPECT_EQ(modules[0].timestamp,
             GetTimestampForModule(GetModuleHandle(nullptr)));
   // System modules are forced to particular stamps and the file header values
   // don't match the on-disk times. Just make sure we got some data here.
   EXPECT_GT(modules[1].timestamp, 0);
 }
 
-void TestOtherProcess(const std::wstring& child_name_suffix) {
+void TestOtherProcess(const base::string16& directory_modification) {
   ProcessInfo process_info;
 
   ::UUID system_uuid;
   ASSERT_EQ(RPC_S_OK, UuidCreate(&system_uuid));
   UUID started_uuid(reinterpret_cast<const uint8_t*>(&system_uuid.Data1));
   ASSERT_EQ(RPC_S_OK, UuidCreate(&system_uuid));
   UUID done_uuid(reinterpret_cast<const uint8_t*>(&system_uuid.Data1));
 
   ScopedKernelHANDLE started(
       CreateEvent(nullptr, true, false, started_uuid.ToString16().c_str()));
   ASSERT_TRUE(started.get());
   ScopedKernelHANDLE done(
       CreateEvent(nullptr, true, false, done_uuid.ToString16().c_str()));
   ASSERT_TRUE(done.get());
 
   base::FilePath test_executable = Paths::Executable();
+
   std::wstring child_test_executable =
-      test_executable.RemoveFinalExtension().value() +
-      L"_process_info_test_child_" + child_name_suffix + L".exe";
+      test_executable.DirName()
+          .Append(directory_modification)
+          .Append(test_executable.BaseName().RemoveFinalExtension().value() +
+                  L"_process_info_test_child.exe")
+          .value();
   // TODO(scottmg): Command line escaping utility.
   std::wstring command_line = child_test_executable + L" " +
                               started_uuid.ToString16() + L" " +
                               done_uuid.ToString16();
   STARTUPINFO startup_info = {0};
   startup_info.cb = sizeof(startup_info);
   PROCESS_INFORMATION process_information;
   ASSERT_TRUE(CreateProcess(child_test_executable.c_str(),
                             &command_line[0],
                             nullptr,
@@ skipping 12 matching lines @@
   ASSERT_EQ(WaitForSingleObject(started.get(), INFINITE), WAIT_OBJECT_0);
 
   ASSERT_TRUE(process_info.Initialize(process_information.hProcess));
 
   // Tell the test it's OK to shut down now that we've read our data.
   SetEvent(done.get());
 
   std::vector<ProcessInfo::Module> modules;
   EXPECT_TRUE(process_info.Modules(&modules));
   ASSERT_GE(modules.size(), 3u);
-  std::wstring child_name = L"\\crashpad_util_test_process_info_test_child_" +
-                            child_name_suffix + L".exe";
+  std::wstring child_name = L"\\crashpad_util_test_process_info_test_child.exe";
   ASSERT_GE(modules[0].name.size(), child_name.size());
   EXPECT_EQ(child_name,
             modules[0].name.substr(modules[0].name.size() - child_name.size()));
   ASSERT_GE(modules[1].name.size(), wcslen(kNtdllName));
   EXPECT_EQ(
       kNtdllName,
       modules[1].name.substr(modules[1].name.size() - wcslen(kNtdllName)));
   // lz32.dll is an uncommonly-used-but-always-available module that the test
   // binary manually loads.
   const wchar_t kLz32dllName[] = L"\\lz32.dll";
   ASSERT_GE(modules.back().name.size(), wcslen(kLz32dllName));
   EXPECT_EQ(kLz32dllName,
             modules.back().name.substr(modules.back().name.size() -
                                        wcslen(kLz32dllName)));
 }
 
-// This test can't run the child if the host OS is x86, and can't read from the
-// child if it is x86 and the child is x64, so it only makes sense to run this
-// if we built as x64.
+TEST(ProcessInfo, OtherProcess) {
+  TestOtherProcess(FILE_PATH_LITERAL("."));
+}
+
 #if defined(ARCH_CPU_64_BITS)
-TEST(ProcessInfo, OtherProcessX64) {
-  TestOtherProcess(L"x64");
+TEST(ProcessInfo, OtherProcessWOW64) {
+#ifndef NDEBUG
+  TestOtherProcess(FILE_PATH_LITERAL("..\\..\\out\\Debug"));
+#else
+  TestOtherProcess(FILE_PATH_LITERAL("..\\..\\out\\Release"));
+#endif
 }
 #endif  // ARCH_CPU_64_BITS
 
-TEST(ProcessInfo, OtherProcessX86) {
-  TestOtherProcess(L"x86");
-}
-
 }  // namespace
 }  // namespace test
 }  // namespace crashpad