Use double cast to avoid VS 2015 64-bit warning

sandbox/win/src/process_policy_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <memory>
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "base/strings/sys_string_conversions.h"
@@ skipping 266 matching lines @@
                        L"ProcessPolicyTest_%08x", pid);
   if (-1 != res) {
     return std::wstring(buff);
   }
   return std::wstring();
 }
 
 // This is the function that is called when testing thread creation.
 // It is expected to set an event that the caller is waiting on.
 DWORD TestThreadFunc(LPVOID lpdwThreadParam) {
-  std::wstring event_name =
-      GenerateEventName(reinterpret_cast<DWORD>(lpdwThreadParam));
+  std::wstring event_name = GenerateEventName(
+      static_cast<DWORD>(reinterpret_cast<uintptr_t>(lpdwThreadParam)));
   if (!event_name.length()) {
     return 1;
   }
   HANDLE event = ::OpenEvent(EVENT_ALL_ACCESS | EVENT_MODIFY_STATE, FALSE,
                              event_name.c_str());
   if (!event) {
     return 1;
   }
   if (!SetEvent(event)) {
     return 1;
   }
   return 0;
 }
 
 SBOX_TESTS_COMMAND int Process_CreateThread(int argc, wchar_t** argv) {
   DWORD pid = ::GetCurrentProcessId();
   std::wstring event_name = GenerateEventName(pid);
   if (!event_name.length()) {
     return SBOX_TEST_FIRST_ERROR;
   }
   HANDLE event = ::CreateEvent(NULL, TRUE, FALSE, event_name.c_str());
   if (!event) {
     return SBOX_TEST_SECOND_ERROR;
   }
 
   DWORD thread_id = 0;
   HANDLE thread = NULL;
   thread = ::CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&TestThreadFunc,
-                          reinterpret_cast<LPVOID>(pid), 0, &thread_id);
+                          reinterpret_cast<LPVOID>(static_cast<uintptr_t>(pid)),
+                          0, &thread_id);
 
   if (!thread) {
     return SBOX_TEST_THIRD_ERROR;
   }
   if (!thread_id) {
     return SBOX_TEST_FOURTH_ERROR;
   }
   if (WaitForSingleObject(thread, INFINITE) != WAIT_OBJECT_0) {
     return SBOX_TEST_FIFTH_ERROR;
   }
@@ skipping 164 matching lines @@
 // This tests that our CreateThread interceptors works when called directly.
 TEST(ProcessPolicyTest, TestCreateThreadOutsideSandbox) {
   DWORD pid = ::GetCurrentProcessId();
   std::wstring event_name = GenerateEventName(pid);
   ASSERT_STRNE(NULL, event_name.c_str());
   HANDLE event = ::CreateEvent(NULL, TRUE, FALSE, event_name.c_str());
   EXPECT_NE(static_cast<HANDLE>(NULL), event);
 
   DWORD thread_id = 0;
   HANDLE thread = NULL;
-  thread = TargetCreateThread(::CreateThread, NULL, 0,
-                              (LPTHREAD_START_ROUTINE)&TestThreadFunc,
-                              reinterpret_cast<LPVOID>(pid), 0, &thread_id);
+  thread = TargetCreateThread(
+      ::CreateThread, NULL, 0, (LPTHREAD_START_ROUTINE)&TestThreadFunc,
+      reinterpret_cast<LPVOID>(static_cast<uintptr_t>(pid)), 0, &thread_id);
   EXPECT_NE(static_cast<HANDLE>(NULL), thread);
   EXPECT_EQ(WAIT_OBJECT_0, WaitForSingleObject(thread, INFINITE));
   EXPECT_EQ(WAIT_OBJECT_0, WaitForSingleObject(event, INFINITE));
 }
 
 }  // namespace sandbox