win: Add HandleToInt() and IntToHandle()

util/win/process_info.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 "util/win/process_info.h"
 
 #include <winternl.h>
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/template_util.h"
 #include "build/build_config.h"
 #include "util/numeric/safe_assignment.h"
 #include "util/win/get_function.h"
+#include "util/win/handle.h"
 #include "util/win/nt_internals.h"
 #include "util/win/ntstatus_logging.h"
 #include "util/win/process_structs.h"
 #include "util/win/scoped_handle.h"
 
 namespace crashpad {
 
 namespace {
 
 NTSTATUS NtQueryInformationProcess(HANDLE process_handle,
@@ skipping 135 matching lines @@
                                           &bytes_returned);
   if (!NT_SUCCESS(status)) {
     NTSTATUS_LOG(ERROR, status) << "NtQueryInformationProcess";
     return false;
   }
   if (bytes_returned != sizeof(process_basic_information)) {
     LOG(ERROR) << "NtQueryInformationProcess incorrect size";
     return false;
   }
 
-  // See https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203 on
-  // 32 bit being the correct size for HANDLEs for proceses, even on Windows
-  // x64. API functions (e.g. OpenProcess) take only a DWORD, so there's no
-  // sense in maintaining the top bits.
+  // API functions (e.g. OpenProcess) take only a DWORD, so there's no sense in
+  // maintaining the top bits.
   process_info->process_id_ =
       static_cast<DWORD>(process_basic_information.UniqueProcessId);
   process_info->inherited_from_process_id_ = static_cast<DWORD>(
       process_basic_information.InheritedFromUniqueProcessId);
 
   // We now want to read the PEB to gather the rest of our information. The
   // PebBaseAddress as returned above is what we want for 64-on-64 and 32-on-32,
   // but for Wow64, we want to read the 32 bit PEB (a Wow64 process has both).
   // The address of this is found by a second call to NtQueryInformationProcess.
   if (!is_wow64) {
@@ skipping 185 matching lines @@
             returned_length);
 
   std::vector<Handle> handles;
 
   for (size_t i = 0; i < system_handle_information_ex.NumberOfHandles; ++i) {
     const auto& handle = system_handle_information_ex.Handles[i];
     if (handle.UniqueProcessId != process_id_)
       continue;
 
     Handle result_handle;
-    result_handle.handle =
-        static_cast<uint32_t>(reinterpret_cast<uintptr_t>(handle.HandleValue));
+    result_handle.handle = HandleToInt(handle.HandleValue);
     result_handle.attributes = handle.HandleAttributes;
     result_handle.granted_access = handle.GrantedAccess;
 
     // TODO(scottmg): Could special case for self.
     HANDLE dup_handle;
     if (DuplicateHandle(process,
-                        reinterpret_cast<HANDLE>(handle.HandleValue),
+                        handle.HandleValue,
                         GetCurrentProcess(),
                         &dup_handle,
                         0,
                         false,
                         DUPLICATE_SAME_ACCESS)) {
       // Some handles cannot be duplicated, for example, handles of type
       // EtwRegistration. If we fail to duplicate, then we can't gather any more
       // information, but include the information that we do have already.
       ScopedKernelHANDLE scoped_dup_handle(dup_handle);
 
@@ skipping 271 matching lines @@
     } else {
       result.push_back(as_ranges[i]);
     }
     DCHECK(result.back().IsValid());
   }
 
   return result;
 }
 
 }  // namespace crashpad