win: Add HandleToInt() and IntToHandle()

client/crashpad_client_win.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 "client/crashpad_client.h"
 
 #include <string.h>
 #include <windows.h>
 
 #include "base/atomicops.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "util/file/file_io.h"
 #include "util/win/command_line.h"
 #include "util/win/critical_section_with_debug_info.h"
+#include "util/win/handle.h"
 #include "util/win/registration_protocol_win.h"
 #include "util/win/scoped_handle.h"
 
 namespace {
 
 // This handle is never closed. This is used to signal to the server that a dump
 // should be taken in the event of a crash.
 HANDLE g_signal_exception = INVALID_HANDLE_VALUE;
 
 // Where we store the exception information that the crash handler reads.
@@ skipping 120 matching lines @@
     AppendCommandLineArgument(FormatArgumentString("url",
                                                    base::UTF8ToUTF16(url)),
                               &command_line);
   }
   for (const auto& kv : annotations) {
     AppendCommandLineArgument(
         FormatArgumentString("annotation",
                              base::UTF8ToUTF16(kv.first + '=' + kv.second)),
         &command_line);
   }
-
-  // According to
-  // https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203, HANDLEs
-  // are always 32 bits.
   AppendCommandLineArgument(
       base::UTF8ToUTF16(base::StringPrintf("--handshake-handle=0x%x",
-                                           pipe_write)),
+                                           HandleToInt(pipe_write))),
       &command_line);
 
   STARTUPINFO startup_info = {};
   startup_info.cb = sizeof(startup_info);
   startup_info.dwFlags = STARTF_USESTDHANDLES;
   startup_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
   startup_info.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
   startup_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
   PROCESS_INFORMATION process_info;
   rv = CreateProcess(handler.value().c_str(),
@@ skipping 78 matching lines @@
         reinterpret_cast<WinVMAddress>(&g_critical_section_with_debug_info);
   }
 
   ServerToClientMessage response = {0};
 
   if (!SendToCrashHandlerServer(ipc_pipe_, message, &response)) {
     return false;
   }
 
   // The server returns these already duplicated to be valid in this process.
-  g_signal_exception = reinterpret_cast<HANDLE>(
-      static_cast<uintptr_t>(response.registration.request_crash_dump_event));
-  g_signal_non_crash_dump = reinterpret_cast<HANDLE>(static_cast<uintptr_t>(
-      response.registration.request_non_crash_dump_event));
-  g_non_crash_dump_done = reinterpret_cast<HANDLE>(static_cast<uintptr_t>(
-      response.registration.non_crash_dump_completed_event));
+  g_signal_exception =
+      IntToHandle(response.registration.request_crash_dump_event);
+  g_signal_non_crash_dump =
+      IntToHandle(response.registration.request_non_crash_dump_event);
+  g_non_crash_dump_done =
+      IntToHandle(response.registration.non_crash_dump_completed_event);
 
   g_non_crash_dump_lock = new base::Lock();
 
   // In theory we could store the previous handler but it is not clear what
   // use we have for it.
   SetUnhandledExceptionFilter(&UnhandledExceptionHandler);
   return true;
 }
 
 // static
@@ skipping 42 matching lines @@
       reinterpret_cast<crashpad::WinVMAddress>(&exception_pointers);
 
   bool set_event_result = !!SetEvent(g_signal_non_crash_dump);
   PLOG_IF(ERROR, !set_event_result) << "SetEvent";
 
   DWORD wfso_result = WaitForSingleObject(g_non_crash_dump_done, INFINITE);
   PLOG_IF(ERROR, wfso_result != WAIT_OBJECT_0) << "WaitForSingleObject";
 }
 
 }  // namespace crashpad