win: Add HandleToInt() and IntToHandle()

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 15 matching lines @@
 #include "build/build_config.h"
 #include "gtest/gtest.h"
 #include "test/errors.h"
 #include "test/scoped_temp_dir.h"
 #include "test/paths.h"
 #include "test/win/child_launcher.h"
 #include "util/file/file_io.h"
 #include "util/misc/uuid.h"
 #include "util/win/command_line.h"
 #include "util/win/get_function.h"
+#include "util/win/handle.h"
 #include "util/win/scoped_handle.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 const wchar_t kNtdllName[] = L"\\ntdll.dll";
 
 bool IsProcessWow64(HANDLE process_handle) {
   static const auto is_wow64_process =
@@ skipping 520 matching lines @@
                                                mapping_name.c_str()));
   ASSERT_TRUE(mapping.is_valid()) << ErrorMessage("CreateFileMapping");
 
   ProcessInfo info;
   info.Initialize(GetCurrentProcess());
   bool found_file_handle = false;
   bool found_inherited_file_handle = false;
   bool found_key_handle = false;
   bool found_mapping_handle = false;
   for (auto handle : info.Handles()) {
-    if (reinterpret_cast<uint32_t>(file.get()) == handle.handle) {
+    const int handle_int = implicit_cast<int>(handle.handle);
+    if (handle_int == HandleToInt(file.get())) {
       EXPECT_FALSE(found_file_handle);
       found_file_handle = true;
       EXPECT_EQ(L"File", handle.type_name);
       EXPECT_EQ(1, handle.handle_count);
       EXPECT_NE(0u, handle.pointer_count);
       EXPECT_EQ(STANDARD_RIGHTS_READ | STANDARD_RIGHTS_WRITE | SYNCHRONIZE,
                 handle.granted_access & STANDARD_RIGHTS_ALL);
       EXPECT_EQ(0, handle.attributes);
     }
-    if (reinterpret_cast<uint32_t>(inherited_file.get()) == handle.handle) {
+    if (handle_int == HandleToInt(inherited_file.get())) {
       EXPECT_FALSE(found_inherited_file_handle);
       found_inherited_file_handle = true;
       EXPECT_EQ(L"File", handle.type_name);
       EXPECT_EQ(1, handle.handle_count);
       EXPECT_NE(0u, handle.pointer_count);
       EXPECT_EQ(STANDARD_RIGHTS_READ | STANDARD_RIGHTS_WRITE | SYNCHRONIZE,
                 handle.granted_access & STANDARD_RIGHTS_ALL);
 
       // OBJ_INHERIT from ntdef.h, but including that conflicts with other
       // headers.
       const int kObjInherit = 0x2;
       EXPECT_EQ(kObjInherit, handle.attributes);
     }
-    if (reinterpret_cast<uint32_t>(scoped_key.get()) == handle.handle) {
+    if (handle_int == HandleToInt(scoped_key.get())) {
       EXPECT_FALSE(found_key_handle);
       found_key_handle = true;
       EXPECT_EQ(L"Key", handle.type_name);
       EXPECT_EQ(1, handle.handle_count);
       EXPECT_NE(0u, handle.pointer_count);
       EXPECT_EQ(STANDARD_RIGHTS_READ,
                 handle.granted_access & STANDARD_RIGHTS_ALL);
       EXPECT_EQ(0, handle.attributes);
     }
-    if (reinterpret_cast<uint32_t>(mapping.get()) == handle.handle) {
+    if (handle_int == HandleToInt(mapping.get())) {
       EXPECT_FALSE(found_mapping_handle);
       found_mapping_handle = true;
       EXPECT_EQ(L"Section", handle.type_name);
       EXPECT_EQ(1, handle.handle_count);
       EXPECT_NE(0u, handle.pointer_count);
       EXPECT_EQ(DELETE | READ_CONTROL | WRITE_DAC | WRITE_OWNER |
                     STANDARD_RIGHTS_READ | STANDARD_RIGHTS_WRITE,
                 handle.granted_access & STANDARD_RIGHTS_ALL);
       EXPECT_EQ(0, handle.attributes);
     }
   }
   EXPECT_TRUE(found_file_handle);
+  EXPECT_TRUE(found_inherited_file_handle);
   EXPECT_TRUE(found_key_handle);
   EXPECT_TRUE(found_mapping_handle);
 }
 
 TEST(ProcessInfo, OutOfRangeCheck) {
   const size_t kAllocationSize = 12345;
   scoped_ptr<char[]> safe_memory(new char[kAllocationSize]);
 
   ProcessInfo info;
   info.Initialize(GetCurrentProcess());
 
   EXPECT_TRUE(
       info.LoggingRangeIsFullyReadable(CheckedRange<WinVMAddress, WinVMSize>(
           reinterpret_cast<WinVMAddress>(safe_memory.get()), kAllocationSize)));
   EXPECT_FALSE(info.LoggingRangeIsFullyReadable(
       CheckedRange<WinVMAddress, WinVMSize>(0, 1024)));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad