win: Get Crashpad compiling under VS2015

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,
@@ skipping 50 matching lines @@
 bool ReadUnicodeString(HANDLE process,
                        const process_types::UNICODE_STRING<T>& us,
                        std::wstring* result) {
   if (us.Length == 0) {
     result->clear();
     return true;
   }
   DCHECK_EQ(us.Length % sizeof(wchar_t), 0u);
   result->resize(us.Length / sizeof(wchar_t));
   SIZE_T bytes_read;
-  if (!ReadProcessMemory(process,
-                         reinterpret_cast<const void*>(us.Buffer),
-                         &result->operator[](0),
-                         us.Length,
-                         &bytes_read)) {
+  if (!ReadProcessMemory(
+          process,
+          reinterpret_cast<const void*>(static_cast<uintptr_t>(us.Buffer)),
+          &result->operator[](0),
+          us.Length,
+          &bytes_read)) {
     PLOG(ERROR) << "ReadProcessMemory UNICODE_STRING";
     return false;
   }
   if (bytes_read != us.Length) {
     LOG(ERROR) << "ReadProcessMemory UNICODE_STRING incorrect size";
     return false;
   }
   return true;
 }
 
@@ skipping 105 matching lines @@
 
   process_types::PEB_LDR_DATA<Traits> peb_ldr_data;
   if (!ReadStruct(process, peb.Ldr, &peb_ldr_data))
     return false;
 
   process_types::LDR_DATA_TABLE_ENTRY<Traits> ldr_data_table_entry;
 
   // Include the first module in the memory order list to get our the main
   // executable's name, as it's not included in initialization order below.
   if (!ReadStruct(process,
-                  reinterpret_cast<WinVMAddress>(
-                      reinterpret_cast<const char*>(
-                          peb_ldr_data.InMemoryOrderModuleList.Flink) -
+                  static_cast<WinVMAddress>(
+                      peb_ldr_data.InMemoryOrderModuleList.Flink) -
                       offsetof(process_types::LDR_DATA_TABLE_ENTRY<Traits>,
-                               InMemoryOrderLinks)),
+                               InMemoryOrderLinks),
                   &ldr_data_table_entry)) {
     return false;
   }
   ProcessInfo::Module module;
   if (!ReadUnicodeString(
           process, ldr_data_table_entry.FullDllName, &module.name)) {
     return false;
   }
   module.dll_base = ldr_data_table_entry.DllBase;
   module.size = ldr_data_table_entry.SizeOfImage;
   module.timestamp = ldr_data_table_entry.TimeDateStamp;
   process_info->modules_.push_back(module);
 
   // Walk the PEB LDR structure (doubly-linked list) to get the list of loaded
   // modules. We use this method rather than EnumProcessModules to get the
   // modules in initialization order rather than memory order.
   Traits::Pointer last = peb_ldr_data.InInitializationOrderModuleList.Blink;
   for (Traits::Pointer cur = peb_ldr_data.InInitializationOrderModuleList.Flink;
        ;
        cur = ldr_data_table_entry.InInitializationOrderLinks.Flink) {
     // |cur| is the pointer to the LIST_ENTRY embedded in the
     // LDR_DATA_TABLE_ENTRY, in the target process's address space. So we need
     // to read from the target, and also offset back to the beginning of the
     // structure.
     if (!ReadStruct(process,
-                    reinterpret_cast<WinVMAddress>(
-                        reinterpret_cast<const char*>(cur) -
+                    static_cast<WinVMAddress>(cur) -
                         offsetof(process_types::LDR_DATA_TABLE_ENTRY<Traits>,
-                                 InInitializationOrderLinks)),
+                                 InInitializationOrderLinks),
                     &ldr_data_table_entry)) {
       break;
     }
     // TODO(scottmg): Capture Checksum, etc. too?
     if (!ReadUnicodeString(
             process, ldr_data_table_entry.FullDllName, &module.name)) {
       break;
     }
     module.dll_base = ldr_data_table_entry.DllBase;
     module.size = ldr_data_table_entry.SizeOfImage;
@@ skipping 102 matching lines @@
   return true;
 }
 
 bool ProcessInfo::Modules(std::vector<Module>* modules) const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   *modules = modules_;
   return true;
 }
 
 }  // namespace crashpad