win: Add HandleToInt() and IntToHandle()

test/win/win_child_process.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 "test/win/win_child_process.h"
 
 #include <windows.h>
 #include <shellapi.h>
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "gtest/gtest.h"
 #include "util/stdlib/string_number_conversion.h"
 #include "util/string/split_string.h"
+#include "util/win/handle.h"
 #include "test/paths.h"
 
 namespace crashpad {
 namespace test {
 
 namespace {
 
 const char kIsMultiprocessChild[] = "--is-multiprocess-child";
 struct LocalFreeTraits {
   static HLOCAL InvalidValue() { return nullptr; }
@@ skipping 107 matching lines @@
   CHECK(GetSwitch(kIsMultiprocessChild, &switch_value));
 
   // Set up the handles we inherited from the parent. These are inherited from
   // the parent and so are open and have the same value as in the parent. The
   // values are passed to the child on the command line.
   std::string left, right;
   CHECK(SplitString(switch_value, '|', &left, &right));
   unsigned int write, read;
   CHECK(StringToNumber(left, &write));
   CHECK(StringToNumber(right, &read));
-  pipe_write_.reset(reinterpret_cast<HANDLE>(static_cast<uintptr_t>(write)));
-  pipe_read_.reset(reinterpret_cast<HANDLE>(static_cast<uintptr_t>(read)));
+  pipe_write_.reset(IntToHandle(write));
+  pipe_read_.reset(IntToHandle(read));
 
   // Notify the parent that it's OK to proceed. We only need to wait to get to
   // the process entry point, but this is the easiest place we can notify.
   char c = ' ';
   CheckedWriteFile(WritePipeHandle(), &c, sizeof(c));
 }
 
 // static
 bool WinChildProcess::IsChildProcess() {
   return GetSwitch(kIsMultiprocessChild, nullptr);
@@ skipping 19 matching lines @@
   // Build a command line for the child process that tells it only to run the
   // current test, and to pass down the values of the pipe handles.
   const ::testing::TestInfo* const test_info =
       ::testing::UnitTest::GetInstance()->current_test_info();
   std::wstring command_line =
       Paths::Executable().value() + L" " +
       base::UTF8ToUTF16(base::StringPrintf("--gtest_filter=%s.%s %s=0x%x|0x%x",
                                            test_info->test_case_name(),
                                            test_info->name(),
                                            kIsMultiprocessChild,
-                                           write_for_child,
-                                           read_for_child.get()));
+                                           HandleToInt(write_for_child.get()),
+                                           HandleToInt(read_for_child.get())));
 
   // Command-line buffer cannot be constant, per CreateProcess signature.
   handles_for_parent->process = LaunchCommandLine(&command_line[0]);
   if (!handles_for_parent->process.is_valid())
     return scoped_ptr<Handles>();
 
   // Block until the child process has launched. CreateProcess() returns
   // immediately, and test code expects process initialization to have
   // completed so it can, for example, read the process memory.
   char c;
@@ skipping 21 matching lines @@
 void WinChildProcess::CloseReadPipe() {
   pipe_read_.reset();
 }
 
 void WinChildProcess::CloseWritePipe() {
   pipe_write_.reset();
 }
 
 }  // namespace test
 }  // namespace crashpad